//===----------------------------------------------------------------------===//
//
// This source file is part of the Soto for AWS open source project
//
// Copyright (c) 2017-2024 the Soto project authors
// Licensed under Apache License v2.0
//
// See LICENSE.txt for license information
// See CONTRIBUTORS.txt for the list of Soto project authors
//
// SPDX-License-Identifier: Apache-2.0
//
//===----------------------------------------------------------------------===//

// THIS FILE IS AUTOMATICALLY GENERATED by https://github.com/soto-project/soto-codegenerator.
// DO NOT EDIT.

#if canImport(FoundationEssentials)
import FoundationEssentials
#else
import Foundation
#endif
@_spi(SotoInternal) import SotoCore

extension Redshift {
    // MARK: Enums

    public enum ActionType: String, CustomStringConvertible, Codable, Sendable, CodingKeyRepresentable {
        case recommendNodeConfig = "recommend-node-config"
        case resizeCluster = "resize-cluster"
        case restoreCluster = "restore-cluster"
        public var description: String { return self.rawValue }
    }

    public enum AquaConfigurationStatus: String, CustomStringConvertible, Codable, Sendable, CodingKeyRepresentable {
        case auto = "auto"
        case disabled = "disabled"
        case enabled = "enabled"
        public var description: String { return self.rawValue }
    }

    public enum AquaStatus: String, CustomStringConvertible, Codable, Sendable, CodingKeyRepresentable {
        case applying = "applying"
        case disabled = "disabled"
        case enabled = "enabled"
        public var description: String { return self.rawValue }
    }

    public enum AuthorizationStatus: String, CustomStringConvertible, Codable, Sendable, CodingKeyRepresentable {
        case authorized = "Authorized"
        case revoking = "Revoking"
        public var description: String { return self.rawValue }
    }

    public enum DataShareStatus: String, CustomStringConvertible, Codable, Sendable, CodingKeyRepresentable {
        case active = "ACTIVE"
        case authorized = "AUTHORIZED"
        case available = "AVAILABLE"
        case deauthorized = "DEAUTHORIZED"
        case pendingAuthorization = "PENDING_AUTHORIZATION"
        case rejected = "REJECTED"
        public var description: String { return self.rawValue }
    }

    public enum DataShareStatusForConsumer: String, CustomStringConvertible, Codable, Sendable, CodingKeyRepresentable {
        case active = "ACTIVE"
        case available = "AVAILABLE"
        public var description: String { return self.rawValue }
    }

    public enum DataShareStatusForProducer: String, CustomStringConvertible, Codable, Sendable, CodingKeyRepresentable {
        case active = "ACTIVE"
        case authorized = "AUTHORIZED"
        case deauthorized = "DEAUTHORIZED"
        case pendingAuthorization = "PENDING_AUTHORIZATION"
        case rejected = "REJECTED"
        public var description: String { return self.rawValue }
    }

    public enum DataShareType: String, CustomStringConvertible, Codable, Sendable, CodingKeyRepresentable {
        case `internal` = "INTERNAL"
        public var description: String { return self.rawValue }
    }

    public enum DescribeIntegrationsFilterName: String, CustomStringConvertible, Codable, Sendable, CodingKeyRepresentable {
        case integrationArn = "integration-arn"
        case sourceArn = "source-arn"
        case sourceTypes = "source-types"
        case status = "status"
        public var description: String { return self.rawValue }
    }

    public enum ImpactRankingType: String, CustomStringConvertible, Codable, Sendable, CodingKeyRepresentable {
        case high = "HIGH"
        case low = "LOW"
        case medium = "MEDIUM"
        public var description: String { return self.rawValue }
    }

    public enum LogDestinationType: String, CustomStringConvertible, Codable, Sendable, CodingKeyRepresentable {
        case cloudwatch = "cloudwatch"
        case s3 = "s3"
        public var description: String { return self.rawValue }
    }

    public enum Mode: String, CustomStringConvertible, Codable, Sendable, CodingKeyRepresentable {
        case highPerformance = "high-performance"
        case standard = "standard"
        public var description: String { return self.rawValue }
    }

    public enum NamespaceRegistrationStatus: String, CustomStringConvertible, Codable, Sendable, CodingKeyRepresentable {
        case deregistering = "Deregistering"
        case registering = "Registering"
        public var description: String { return self.rawValue }
    }

    public enum NodeConfigurationOptionsFilterName: String, CustomStringConvertible, Codable, Sendable, CodingKeyRepresentable {
        case estimatedDiskUtilizationPercent = "EstimatedDiskUtilizationPercent"
        case mode = "Mode"
        case nodeType = "NodeType"
        case numNodes = "NumberOfNodes"
        public var description: String { return self.rawValue }
    }

    public enum OperatorType: String, CustomStringConvertible, Codable, Sendable, CodingKeyRepresentable {
        case `in` = "in"
        case between = "between"
        case eq = "eq"
        case ge = "ge"
        case gt = "gt"
        case le = "le"
        case lt = "lt"
        public var description: String { return self.rawValue }
    }

    public enum ParameterApplyType: String, CustomStringConvertible, Codable, Sendable, CodingKeyRepresentable {
        case `static` = "static"
        case dynamic = "dynamic"
        public var description: String { return self.rawValue }
    }

    public enum PartnerIntegrationStatus: String, CustomStringConvertible, Codable, Sendable, CodingKeyRepresentable {
        case active = "Active"
        case connectionFailure = "ConnectionFailure"
        case inactive = "Inactive"
        case runtimeFailure = "RuntimeFailure"
        public var description: String { return self.rawValue }
    }

    public enum RecommendedActionType: String, CustomStringConvertible, Codable, Sendable, CodingKeyRepresentable {
        case cli = "CLI"
        case sql = "SQL"
        public var description: String { return self.rawValue }
    }

    public enum ReservedNodeExchangeActionType: String, CustomStringConvertible, Codable, Sendable, CodingKeyRepresentable {
        case resizeCluster = "resize-cluster"
        case restoreCluster = "restore-cluster"
        public var description: String { return self.rawValue }
    }

    public enum ReservedNodeExchangeStatusType: String, CustomStringConvertible, Codable, Sendable, CodingKeyRepresentable {
        case failed = "FAILED"
        case inProgress = "IN_PROGRESS"
        case pending = "PENDING"
        case requested = "REQUESTED"
        case retrying = "RETRYING"
        case succeeded = "SUCCEEDED"
        public var description: String { return self.rawValue }
    }

    public enum ReservedNodeOfferingType: String, CustomStringConvertible, Codable, Sendable, CodingKeyRepresentable {
        case regular = "Regular"
        case upgradable = "Upgradable"
        public var description: String { return self.rawValue }
    }

    public enum ScheduleState: String, CustomStringConvertible, Codable, Sendable, CodingKeyRepresentable {
        case active = "ACTIVE"
        case failed = "FAILED"
        case modifying = "MODIFYING"
        public var description: String { return self.rawValue }
    }

    public enum ScheduledActionFilterName: String, CustomStringConvertible, Codable, Sendable, CodingKeyRepresentable {
        case clusterIdentifier = "cluster-identifier"
        case iamRole = "iam-role"
        public var description: String { return self.rawValue }
    }

    public enum ScheduledActionState: String, CustomStringConvertible, Codable, Sendable, CodingKeyRepresentable {
        case active = "ACTIVE"
        case disabled = "DISABLED"
        public var description: String { return self.rawValue }
    }

    public enum ScheduledActionTypeValues: String, CustomStringConvertible, Codable, Sendable, CodingKeyRepresentable {
        case pauseCluster = "PauseCluster"
        case resizeCluster = "ResizeCluster"
        case resumeCluster = "ResumeCluster"
        public var description: String { return self.rawValue }
    }

    public enum ServiceAuthorization: String, CustomStringConvertible, Codable, Sendable, CodingKeyRepresentable {
        case disabled = "Disabled"
        case enabled = "Enabled"
        public var description: String { return self.rawValue }
    }

    public enum SnapshotAttributeToSortBy: String, CustomStringConvertible, Codable, Sendable, CodingKeyRepresentable {
        case createTime = "CREATE_TIME"
        case sourceType = "SOURCE_TYPE"
        case totalSize = "TOTAL_SIZE"
        public var description: String { return self.rawValue }
    }

    public enum SortByOrder: String, CustomStringConvertible, Codable, Sendable, CodingKeyRepresentable {
        case ascending = "ASC"
        case descending = "DESC"
        public var description: String { return self.rawValue }
    }

    public enum SourceType: String, CustomStringConvertible, Codable, Sendable, CodingKeyRepresentable {
        case cluster = "cluster"
        case clusterParameterGroup = "cluster-parameter-group"
        case clusterSecurityGroup = "cluster-security-group"
        case clusterSnapshot = "cluster-snapshot"
        case scheduledAction = "scheduled-action"
        public var description: String { return self.rawValue }
    }

    public enum TableRestoreStatusType: String, CustomStringConvertible, Codable, Sendable, CodingKeyRepresentable {
        case canceled = "CANCELED"
        case failed = "FAILED"
        case inProgress = "IN_PROGRESS"
        case pending = "PENDING"
        case succeeded = "SUCCEEDED"
        public var description: String { return self.rawValue }
    }

    public enum UsageLimitBreachAction: String, CustomStringConvertible, Codable, Sendable, CodingKeyRepresentable {
        case disable = "disable"
        case emitMetric = "emit-metric"
        case log = "log"
        public var description: String { return self.rawValue }
    }

    public enum UsageLimitFeatureType: String, CustomStringConvertible, Codable, Sendable, CodingKeyRepresentable {
        case concurrencyScaling = "concurrency-scaling"
        case crossRegionDatasharing = "cross-region-datasharing"
        case spectrum = "spectrum"
        public var description: String { return self.rawValue }
    }

    public enum UsageLimitLimitType: String, CustomStringConvertible, Codable, Sendable, CodingKeyRepresentable {
        case dataScanned = "data-scanned"
        case time = "time"
        public var description: String { return self.rawValue }
    }

    public enum UsageLimitPeriod: String, CustomStringConvertible, Codable, Sendable, CodingKeyRepresentable {
        case daily = "daily"
        case monthly = "monthly"
        case weekly = "weekly"
        public var description: String { return self.rawValue }
    }

    public enum ZeroETLIntegrationStatus: String, CustomStringConvertible, Codable, Sendable, CodingKeyRepresentable {
        case active = "active"
        case creating = "creating"
        case deleting = "deleting"
        case failed = "failed"
        case modifying = "modifying"
        case needsAttention = "needs_attention"
        case syncing = "syncing"
        public var description: String { return self.rawValue }
    }

    public enum NamespaceIdentifierUnion: AWSEncodableShape, Sendable {
        /// The identifier for a provisioned cluster.
        case provisionedIdentifier(ProvisionedIdentifier)
        /// The identifier for a serverless namespace.
        case serverlessIdentifier(ServerlessIdentifier)

        public func encode(to encoder: Encoder) throws {
            var container = encoder.container(keyedBy: CodingKeys.self)
            switch self {
            case .provisionedIdentifier(let value):
                try container.encode(value, forKey: .provisionedIdentifier)
            case .serverlessIdentifier(let value):
                try container.encode(value, forKey: .serverlessIdentifier)
            }
        }

        public func validate(name: String) throws {
            switch self {
            case .provisionedIdentifier(let value):
                try value.validate(name: "\(name).provisionedIdentifier")
            case .serverlessIdentifier(let value):
                try value.validate(name: "\(name).serverlessIdentifier")
            }
        }

        private enum CodingKeys: String, CodingKey {
            case provisionedIdentifier = "ProvisionedIdentifier"
            case serverlessIdentifier = "ServerlessIdentifier"
        }
    }

    public enum ServiceIntegrationsUnion: AWSEncodableShape & AWSDecodableShape, Sendable {
        /// A list of scopes set up for Lake Formation integration.
        case lakeFormation([LakeFormationScopeUnion])
        /// A list of scopes set up for S3 Access Grants integration.
        case s3AccessGrants([S3AccessGrantsScopeUnion])

        public init(from decoder: Decoder) throws {
            let container = try decoder.container(keyedBy: CodingKeys.self)
            guard container.allKeys.count == 1, let key = container.allKeys.first else {
                let context = DecodingError.Context(
                    codingPath: container.codingPath,
                    debugDescription: "Expected exactly one key, but got \(container.allKeys.count)"
                )
                throw DecodingError.dataCorrupted(context)
            }
            switch key {
            case .lakeFormation:
                let value = try container.decode([LakeFormationScopeUnion].self, forKey: .lakeFormation)
                self = .lakeFormation(value)
            case .s3AccessGrants:
                let value = try container.decode([S3AccessGrantsScopeUnion].self, forKey: .s3AccessGrants)
                self = .s3AccessGrants(value)
            }
        }

        public func encode(to encoder: Encoder) throws {
            var container = encoder.container(keyedBy: CodingKeys.self)
            switch self {
            case .lakeFormation(let value):
                try container.encode(value, forKey: .lakeFormation)
            case .s3AccessGrants(let value):
                try container.encode(value, forKey: .s3AccessGrants)
            }
        }

        private enum CodingKeys: String, CodingKey {
            case lakeFormation = "LakeFormation"
            case s3AccessGrants = "S3AccessGrants"
        }
    }

    // MARK: Shapes

    public struct AcceptReservedNodeExchangeInputMessage: AWSEncodableShape {
        /// A string representing the node identifier of the DC1 Reserved Node to be exchanged.
        public let reservedNodeId: String?
        /// The unique identifier of the DC2 Reserved Node offering to be used for the exchange. You can obtain the value for the parameter by calling GetReservedNodeExchangeOfferings
        public let targetReservedNodeOfferingId: String?

        @inlinable
        public init(reservedNodeId: String? = nil, targetReservedNodeOfferingId: String? = nil) {
            self.reservedNodeId = reservedNodeId
            self.targetReservedNodeOfferingId = targetReservedNodeOfferingId
        }

        public func validate(name: String) throws {
            try self.validate(self.reservedNodeId, name: "reservedNodeId", parent: name, max: 2147483647)
            try self.validate(self.targetReservedNodeOfferingId, name: "targetReservedNodeOfferingId", parent: name, max: 2147483647)
        }

        private enum CodingKeys: String, CodingKey {
            case reservedNodeId = "ReservedNodeId"
            case targetReservedNodeOfferingId = "TargetReservedNodeOfferingId"
        }
    }

    public struct AcceptReservedNodeExchangeOutputMessage: AWSDecodableShape {
        public let exchangedReservedNode: ReservedNode?

        @inlinable
        public init(exchangedReservedNode: ReservedNode? = nil) {
            self.exchangedReservedNode = exchangedReservedNode
        }

        private enum CodingKeys: String, CodingKey {
            case exchangedReservedNode = "ExchangedReservedNode"
        }
    }

    public struct AccountAttribute: AWSDecodableShape {
        public struct _AttributeValuesEncoding: ArrayCoderProperties { public static let member = "AttributeValueTarget" }

        /// The name of the attribute.
        public let attributeName: String?
        /// A list of attribute values.
        @OptionalCustomCoding<ArrayCoder<_AttributeValuesEncoding, AttributeValueTarget>>
        public var attributeValues: [AttributeValueTarget]?

        @inlinable
        public init(attributeName: String? = nil, attributeValues: [AttributeValueTarget]? = nil) {
            self.attributeName = attributeName
            self.attributeValues = attributeValues
        }

        private enum CodingKeys: String, CodingKey {
            case attributeName = "AttributeName"
            case attributeValues = "AttributeValues"
        }
    }

    public struct AccountAttributeList: AWSDecodableShape {
        public struct _AccountAttributesEncoding: ArrayCoderProperties { public static let member = "AccountAttribute" }

        /// A list of attributes assigned to an account.
        @OptionalCustomCoding<ArrayCoder<_AccountAttributesEncoding, AccountAttribute>>
        public var accountAttributes: [AccountAttribute]?

        @inlinable
        public init(accountAttributes: [AccountAttribute]? = nil) {
            self.accountAttributes = accountAttributes
        }

        private enum CodingKeys: String, CodingKey {
            case accountAttributes = "AccountAttributes"
        }
    }

    public struct AccountWithRestoreAccess: AWSDecodableShape {
        /// The identifier of an Amazon Web Services support account authorized to restore a  snapshot. For Amazon Web Services Support, the identifier is amazon-redshift-support.
        public let accountAlias: String?
        /// The identifier of an Amazon Web Services account authorized to restore a snapshot.
        public let accountId: String?

        @inlinable
        public init(accountAlias: String? = nil, accountId: String? = nil) {
            self.accountAlias = accountAlias
            self.accountId = accountId
        }

        private enum CodingKeys: String, CodingKey {
            case accountAlias = "AccountAlias"
            case accountId = "AccountId"
        }
    }

    public struct AquaConfiguration: AWSDecodableShape {
        /// This field is retired. Amazon Redshift automatically determines whether to use AQUA (Advanced Query Accelerator).
        public let aquaConfigurationStatus: AquaConfigurationStatus?
        /// This field is retired. Amazon Redshift automatically determines whether to use AQUA (Advanced Query Accelerator).
        public let aquaStatus: AquaStatus?

        @inlinable
        public init(aquaConfigurationStatus: AquaConfigurationStatus? = nil, aquaStatus: AquaStatus? = nil) {
            self.aquaConfigurationStatus = aquaConfigurationStatus
            self.aquaStatus = aquaStatus
        }

        private enum CodingKeys: String, CodingKey {
            case aquaConfigurationStatus = "AquaConfigurationStatus"
            case aquaStatus = "AquaStatus"
        }
    }

    public struct AssociateDataShareConsumerMessage: AWSEncodableShape {
        /// If set to true, allows write operations for a datashare.
        public let allowWrites: Bool?
        /// A value that specifies whether the datashare is associated with the entire account.
        public let associateEntireAccount: Bool?
        /// The Amazon Resource Name (ARN) of the consumer namespace associated with the datashare.
        public let consumerArn: String?
        /// From a datashare consumer account, associates a datashare with all existing and future namespaces in the specified Amazon Web Services Region.
        public let consumerRegion: String?
        /// The Amazon Resource Name (ARN) of the datashare that the consumer is to use.
        public let dataShareArn: String?

        @inlinable
        public init(allowWrites: Bool? = nil, associateEntireAccount: Bool? = nil, consumerArn: String? = nil, consumerRegion: String? = nil, dataShareArn: String? = nil) {
            self.allowWrites = allowWrites
            self.associateEntireAccount = associateEntireAccount
            self.consumerArn = consumerArn
            self.consumerRegion = consumerRegion
            self.dataShareArn = dataShareArn
        }

        public func validate(name: String) throws {
            try self.validate(self.consumerArn, name: "consumerArn", parent: name, max: 2147483647)
            try self.validate(self.consumerRegion, name: "consumerRegion", parent: name, max: 2147483647)
            try self.validate(self.dataShareArn, name: "dataShareArn", parent: name, max: 2147483647)
        }

        private enum CodingKeys: String, CodingKey {
            case allowWrites = "AllowWrites"
            case associateEntireAccount = "AssociateEntireAccount"
            case consumerArn = "ConsumerArn"
            case consumerRegion = "ConsumerRegion"
            case dataShareArn = "DataShareArn"
        }
    }

    public struct Association: AWSDecodableShape {
        public struct _CertificateAssociationsEncoding: ArrayCoderProperties { public static let member = "CertificateAssociation" }

        /// A list of all associated clusters and domain names tied to a specific certificate.
        @OptionalCustomCoding<ArrayCoder<_CertificateAssociationsEncoding, CertificateAssociation>>
        public var certificateAssociations: [CertificateAssociation]?
        /// The Amazon Resource Name (ARN) for the certificate associated with the custom domain.
        public let customDomainCertificateArn: String?
        /// The expiration date for the certificate.
        public let customDomainCertificateExpiryDate: Date?

        @inlinable
        public init(certificateAssociations: [CertificateAssociation]? = nil, customDomainCertificateArn: String? = nil, customDomainCertificateExpiryDate: Date? = nil) {
            self.certificateAssociations = certificateAssociations
            self.customDomainCertificateArn = customDomainCertificateArn
            self.customDomainCertificateExpiryDate = customDomainCertificateExpiryDate
        }

        private enum CodingKeys: String, CodingKey {
            case certificateAssociations = "CertificateAssociations"
            case customDomainCertificateArn = "CustomDomainCertificateArn"
            case customDomainCertificateExpiryDate = "CustomDomainCertificateExpiryDate"
        }
    }

    public struct AttributeValueTarget: AWSDecodableShape {
        /// The value of the attribute.
        public let attributeValue: String?

        @inlinable
        public init(attributeValue: String? = nil) {
            self.attributeValue = attributeValue
        }

        private enum CodingKeys: String, CodingKey {
            case attributeValue = "AttributeValue"
        }
    }

    public struct AuthenticationProfile: AWSDecodableShape {
        /// The content of the authentication profile in JSON format. The maximum length of the JSON string is determined by a quota for your account.
        public let authenticationProfileContent: String?
        /// The name of the authentication profile.
        public let authenticationProfileName: String?

        @inlinable
        public init(authenticationProfileContent: String? = nil, authenticationProfileName: String? = nil) {
            self.authenticationProfileContent = authenticationProfileContent
            self.authenticationProfileName = authenticationProfileName
        }

        private enum CodingKeys: String, CodingKey {
            case authenticationProfileContent = "AuthenticationProfileContent"
            case authenticationProfileName = "AuthenticationProfileName"
        }
    }

    public struct AuthorizeClusterSecurityGroupIngressMessage: AWSEncodableShape {
        /// The IP range to be added the Amazon Redshift security group.
        public let cidrip: String?
        /// The name of the security group to which the ingress rule is added.
        public let clusterSecurityGroupName: String?
        /// The EC2 security group to be added the Amazon Redshift security group.
        public let ec2SecurityGroupName: String?
        /// The Amazon Web Services account number of the owner of the security group specified by the EC2SecurityGroupName parameter. The Amazon Web Services Access Key ID is not an acceptable value.  Example: 111122223333
        public let ec2SecurityGroupOwnerId: String?

        @inlinable
        public init(cidrip: String? = nil, clusterSecurityGroupName: String? = nil, ec2SecurityGroupName: String? = nil, ec2SecurityGroupOwnerId: String? = nil) {
            self.cidrip = cidrip
            self.clusterSecurityGroupName = clusterSecurityGroupName
            self.ec2SecurityGroupName = ec2SecurityGroupName
            self.ec2SecurityGroupOwnerId = ec2SecurityGroupOwnerId
        }

        public func validate(name: String) throws {
            try self.validate(self.cidrip, name: "cidrip", parent: name, max: 2147483647)
            try self.validate(self.clusterSecurityGroupName, name: "clusterSecurityGroupName", parent: name, max: 2147483647)
            try self.validate(self.ec2SecurityGroupName, name: "ec2SecurityGroupName", parent: name, max: 2147483647)
            try self.validate(self.ec2SecurityGroupOwnerId, name: "ec2SecurityGroupOwnerId", parent: name, max: 2147483647)
        }

        private enum CodingKeys: String, CodingKey {
            case cidrip = "CIDRIP"
            case clusterSecurityGroupName = "ClusterSecurityGroupName"
            case ec2SecurityGroupName = "EC2SecurityGroupName"
            case ec2SecurityGroupOwnerId = "EC2SecurityGroupOwnerId"
        }
    }

    public struct AuthorizeClusterSecurityGroupIngressResult: AWSDecodableShape {
        public let clusterSecurityGroup: ClusterSecurityGroup?

        @inlinable
        public init(clusterSecurityGroup: ClusterSecurityGroup? = nil) {
            self.clusterSecurityGroup = clusterSecurityGroup
        }

        private enum CodingKeys: String, CodingKey {
            case clusterSecurityGroup = "ClusterSecurityGroup"
        }
    }

    public struct AuthorizeDataShareMessage: AWSEncodableShape {
        /// If set to true, allows write operations for a datashare.
        public let allowWrites: Bool?
        /// The identifier of the data consumer that is authorized to access the datashare. This identifier is an Amazon Web Services account ID or a keyword, such as ADX.
        public let consumerIdentifier: String?
        /// The Amazon Resource Name (ARN) of the datashare namespace that producers are to authorize sharing for.
        public let dataShareArn: String?

        @inlinable
        public init(allowWrites: Bool? = nil, consumerIdentifier: String? = nil, dataShareArn: String? = nil) {
            self.allowWrites = allowWrites
            self.consumerIdentifier = consumerIdentifier
            self.dataShareArn = dataShareArn
        }

        public func validate(name: String) throws {
            try self.validate(self.consumerIdentifier, name: "consumerIdentifier", parent: name, max: 2147483647)
            try self.validate(self.dataShareArn, name: "dataShareArn", parent: name, max: 2147483647)
        }

        private enum CodingKeys: String, CodingKey {
            case allowWrites = "AllowWrites"
            case consumerIdentifier = "ConsumerIdentifier"
            case dataShareArn = "DataShareArn"
        }
    }

    public struct AuthorizeEndpointAccessMessage: AWSEncodableShape {
        public struct _VpcIdsEncoding: ArrayCoderProperties { public static let member = "VpcIdentifier" }

        /// The Amazon Web Services account ID to grant access to.
        public let account: String?
        /// The cluster identifier of the cluster to grant access to.
        public let clusterIdentifier: String?
        /// The virtual private cloud (VPC) identifiers to grant access to.
        @OptionalCustomCoding<ArrayCoder<_VpcIdsEncoding, String>>
        public var vpcIds: [String]?

        @inlinable
        public init(account: String? = nil, clusterIdentifier: String? = nil, vpcIds: [String]? = nil) {
            self.account = account
            self.clusterIdentifier = clusterIdentifier
            self.vpcIds = vpcIds
        }

        public func validate(name: String) throws {
            try self.validate(self.account, name: "account", parent: name, max: 2147483647)
            try self.validate(self.clusterIdentifier, name: "clusterIdentifier", parent: name, max: 2147483647)
            try self.vpcIds?.forEach {
                try validate($0, name: "vpcIds[]", parent: name, max: 2147483647)
            }
        }

        private enum CodingKeys: String, CodingKey {
            case account = "Account"
            case clusterIdentifier = "ClusterIdentifier"
            case vpcIds = "VpcIds"
        }
    }

    public struct AuthorizeSnapshotAccessMessage: AWSEncodableShape {
        /// The identifier of the Amazon Web Services account authorized to restore the specified snapshot. To share a snapshot with Amazon Web Services Support, specify amazon-redshift-support.
        public let accountWithRestoreAccess: String?
        /// The Amazon Resource Name (ARN) of the snapshot to authorize access to.
        public let snapshotArn: String?
        /// The identifier of the cluster the snapshot was created from.    If the snapshot to access doesn't exist and the associated IAM policy doesn't allow access to all (*) snapshots -  This parameter is required. Otherwise, permissions  aren't available to check if the snapshot exists.    If the snapshot to access exists - This parameter isn't required. Redshift can retrieve the cluster identifier and use it to  validate snapshot authorization.
        public let snapshotClusterIdentifier: String?
        /// The identifier of the snapshot the account is authorized to restore.
        public let snapshotIdentifier: String?

        @inlinable
        public init(accountWithRestoreAccess: String? = nil, snapshotArn: String? = nil, snapshotClusterIdentifier: String? = nil, snapshotIdentifier: String? = nil) {
            self.accountWithRestoreAccess = accountWithRestoreAccess
            self.snapshotArn = snapshotArn
            self.snapshotClusterIdentifier = snapshotClusterIdentifier
            self.snapshotIdentifier = snapshotIdentifier
        }

        public func validate(name: String) throws {
            try self.validate(self.accountWithRestoreAccess, name: "accountWithRestoreAccess", parent: name, max: 2147483647)
            try self.validate(self.snapshotArn, name: "snapshotArn", parent: name, max: 2147483647)
            try self.validate(self.snapshotClusterIdentifier, name: "snapshotClusterIdentifier", parent: name, max: 2147483647)
            try self.validate(self.snapshotIdentifier, name: "snapshotIdentifier", parent: name, max: 2147483647)
        }

        private enum CodingKeys: String, CodingKey {
            case accountWithRestoreAccess = "AccountWithRestoreAccess"
            case snapshotArn = "SnapshotArn"
            case snapshotClusterIdentifier = "SnapshotClusterIdentifier"
            case snapshotIdentifier = "SnapshotIdentifier"
        }
    }

    public struct AuthorizeSnapshotAccessResult: AWSDecodableShape {
        public let snapshot: Snapshot?

        @inlinable
        public init(snapshot: Snapshot? = nil) {
            self.snapshot = snapshot
        }

        private enum CodingKeys: String, CodingKey {
            case snapshot = "Snapshot"
        }
    }

    public struct AuthorizedTokenIssuer: AWSEncodableShape & AWSDecodableShape {
        /// The list of audiences for the authorized token issuer for integrating Amazon Redshift  with IDC Identity Center.
        @OptionalCustomCoding<StandardArrayCoder<String>>
        public var authorizedAudiencesList: [String]?
        /// The ARN for the authorized token issuer for integrating Amazon Redshift with IDC Identity Center.
        public let trustedTokenIssuerArn: String?

        @inlinable
        public init(authorizedAudiencesList: [String]? = nil, trustedTokenIssuerArn: String? = nil) {
            self.authorizedAudiencesList = authorizedAudiencesList
            self.trustedTokenIssuerArn = trustedTokenIssuerArn
        }

        public func validate(name: String) throws {
            try self.authorizedAudiencesList?.forEach {
                try validate($0, name: "authorizedAudiencesList[]", parent: name, max: 2147483647)
            }
            try self.validate(self.trustedTokenIssuerArn, name: "trustedTokenIssuerArn", parent: name, max: 2147483647)
        }

        private enum CodingKeys: String, CodingKey {
            case authorizedAudiencesList = "AuthorizedAudiencesList"
            case trustedTokenIssuerArn = "TrustedTokenIssuerArn"
        }
    }

    public struct AvailabilityZone: AWSDecodableShape {
        public struct _SupportedPlatformsEncoding: ArrayCoderProperties { public static let member = "SupportedPlatform" }

        /// The name of the availability zone.
        public let name: String?
        @OptionalCustomCoding<ArrayCoder<_SupportedPlatformsEncoding, SupportedPlatform>>
        public var supportedPlatforms: [SupportedPlatform]?

        @inlinable
        public init(name: String? = nil, supportedPlatforms: [SupportedPlatform]? = nil) {
            self.name = name
            self.supportedPlatforms = supportedPlatforms
        }

        private enum CodingKeys: String, CodingKey {
            case name = "Name"
            case supportedPlatforms = "SupportedPlatforms"
        }
    }

    public struct BatchDeleteClusterSnapshotsRequest: AWSEncodableShape {
        public struct _IdentifiersEncoding: ArrayCoderProperties { public static let member = "DeleteClusterSnapshotMessage" }

        /// A list of identifiers for the snapshots that you want to delete.
        @OptionalCustomCoding<ArrayCoder<_IdentifiersEncoding, DeleteClusterSnapshotMessage>>
        public var identifiers: [DeleteClusterSnapshotMessage]?

        @inlinable
        public init(identifiers: [DeleteClusterSnapshotMessage]? = nil) {
            self.identifiers = identifiers
        }

        public func validate(name: String) throws {
            try self.identifiers?.forEach {
                try $0.validate(name: "\(name).identifiers[]")
            }
        }

        private enum CodingKeys: String, CodingKey {
            case identifiers = "Identifiers"
        }
    }

    public struct BatchDeleteClusterSnapshotsResult: AWSDecodableShape {
        public struct _ErrorsEncoding: ArrayCoderProperties { public static let member = "SnapshotErrorMessage" }
        public struct _ResourcesEncoding: ArrayCoderProperties { public static let member = "String" }

        /// A list of any errors returned.
        @OptionalCustomCoding<ArrayCoder<_ErrorsEncoding, SnapshotErrorMessage>>
        public var errors: [SnapshotErrorMessage]?
        /// A list of the snapshot identifiers that were deleted.
        @OptionalCustomCoding<ArrayCoder<_ResourcesEncoding, String>>
        public var resources: [String]?

        @inlinable
        public init(errors: [SnapshotErrorMessage]? = nil, resources: [String]? = nil) {
            self.errors = errors
            self.resources = resources
        }

        private enum CodingKeys: String, CodingKey {
            case errors = "Errors"
            case resources = "Resources"
        }
    }

    public struct BatchModifyClusterSnapshotsMessage: AWSEncodableShape {
        public struct _SnapshotIdentifierListEncoding: ArrayCoderProperties { public static let member = "String" }

        /// A boolean value indicating whether to override an exception if the retention period has passed.
        public let force: Bool?
        /// The number of days that a manual snapshot is retained. If you specify the value -1, the manual snapshot is retained indefinitely. The number must be either -1 or an integer between 1 and 3,653. If you decrease the manual snapshot retention period from its current value, existing manual snapshots that fall outside of the new retention period will return an error. If you want to suppress the errors and delete the snapshots, use the force option.
        public let manualSnapshotRetentionPeriod: Int?
        /// A list of snapshot identifiers you want to modify.
        @OptionalCustomCoding<ArrayCoder<_SnapshotIdentifierListEncoding, String>>
        public var snapshotIdentifierList: [String]?

        @inlinable
        public init(force: Bool? = nil, manualSnapshotRetentionPeriod: Int? = nil, snapshotIdentifierList: [String]? = nil) {
            self.force = force
            self.manualSnapshotRetentionPeriod = manualSnapshotRetentionPeriod
            self.snapshotIdentifierList = snapshotIdentifierList
        }

        public func validate(name: String) throws {
            try self.snapshotIdentifierList?.forEach {
                try validate($0, name: "snapshotIdentifierList[]", parent: name, max: 2147483647)
            }
        }

        private enum CodingKeys: String, CodingKey {
            case force = "Force"
            case manualSnapshotRetentionPeriod = "ManualSnapshotRetentionPeriod"
            case snapshotIdentifierList = "SnapshotIdentifierList"
        }
    }

    public struct BatchModifyClusterSnapshotsOutputMessage: AWSDecodableShape {
        public struct _ErrorsEncoding: ArrayCoderProperties { public static let member = "SnapshotErrorMessage" }
        public struct _ResourcesEncoding: ArrayCoderProperties { public static let member = "String" }

        /// A list of any errors returned.
        @OptionalCustomCoding<ArrayCoder<_ErrorsEncoding, SnapshotErrorMessage>>
        public var errors: [SnapshotErrorMessage]?
        /// A list of the snapshots that were modified.
        @OptionalCustomCoding<ArrayCoder<_ResourcesEncoding, String>>
        public var resources: [String]?

        @inlinable
        public init(errors: [SnapshotErrorMessage]? = nil, resources: [String]? = nil) {
            self.errors = errors
            self.resources = resources
        }

        private enum CodingKeys: String, CodingKey {
            case errors = "Errors"
            case resources = "Resources"
        }
    }

    public struct CancelResizeMessage: AWSEncodableShape {
        /// The unique identifier for the cluster that you want to cancel a resize operation for.
        public let clusterIdentifier: String?

        @inlinable
        public init(clusterIdentifier: String? = nil) {
            self.clusterIdentifier = clusterIdentifier
        }

        public func validate(name: String) throws {
            try self.validate(self.clusterIdentifier, name: "clusterIdentifier", parent: name, max: 2147483647)
        }

        private enum CodingKeys: String, CodingKey {
            case clusterIdentifier = "ClusterIdentifier"
        }
    }

    public struct CertificateAssociation: AWSDecodableShape {
        /// The cluster identifier for the certificate association.
        public let clusterIdentifier: String?
        /// The custom domain name for the certificate association.
        public let customDomainName: String?

        @inlinable
        public init(clusterIdentifier: String? = nil, customDomainName: String? = nil) {
            self.clusterIdentifier = clusterIdentifier
            self.customDomainName = customDomainName
        }

        private enum CodingKeys: String, CodingKey {
            case clusterIdentifier = "ClusterIdentifier"
            case customDomainName = "CustomDomainName"
        }
    }

    public struct Cluster: AWSDecodableShape {
        public struct _ClusterParameterGroupsEncoding: ArrayCoderProperties { public static let member = "ClusterParameterGroup" }
        public struct _ClusterSecurityGroupsEncoding: ArrayCoderProperties { public static let member = "ClusterSecurityGroup" }
        public struct _DeferredMaintenanceWindowsEncoding: ArrayCoderProperties { public static let member = "DeferredMaintenanceWindow" }
        public struct _IamRolesEncoding: ArrayCoderProperties { public static let member = "ClusterIamRole" }
        public struct _TagsEncoding: ArrayCoderProperties { public static let member = "Tag" }
        public struct _VpcSecurityGroupsEncoding: ArrayCoderProperties { public static let member = "VpcSecurityGroup" }

        /// A boolean value that, if true, indicates that major version upgrades will be applied automatically to the cluster during the maintenance window.
        public let allowVersionUpgrade: Bool?
        /// This field is retired. Amazon Redshift automatically determines whether to use AQUA (Advanced Query Accelerator).
        public let aquaConfiguration: AquaConfiguration?
        /// The number of days that automatic cluster snapshots are retained.
        public let automatedSnapshotRetentionPeriod: Int?
        /// The name of the Availability Zone in which the cluster is located.
        public let availabilityZone: String?
        /// Describes the status of the Availability Zone relocation operation.
        public let availabilityZoneRelocationStatus: String?
        /// The availability status of the cluster for queries. Possible values are the following:   Available - The cluster is available for queries.    Unavailable - The cluster is not available for queries.   Maintenance - The cluster is intermittently available for queries due to maintenance activities.   Modifying - The cluster is intermittently available for queries due to changes that modify the cluster.   Failed - The cluster failed and is not available for queries.
        public let clusterAvailabilityStatus: String?
        /// The date and time that the cluster was created.
        public let clusterCreateTime: Date?
        /// The unique identifier of the cluster.
        public let clusterIdentifier: String?
        /// The namespace Amazon Resource Name (ARN) of the cluster.
        public let clusterNamespaceArn: String?
        /// The nodes in the cluster.
        @OptionalCustomCoding<StandardArrayCoder<ClusterNode>>
        public var clusterNodes: [ClusterNode]?
        /// The list of cluster parameter groups that are associated with this cluster. Each parameter group in the list is returned with its status.
        @OptionalCustomCoding<ArrayCoder<_ClusterParameterGroupsEncoding, ClusterParameterGroupStatus>>
        public var clusterParameterGroups: [ClusterParameterGroupStatus]?
        /// The public key for the cluster.
        public let clusterPublicKey: String?
        /// The specific revision number of the database in the cluster.
        public let clusterRevisionNumber: String?
        /// A list of cluster security group that are associated with the cluster. Each security group is represented by an element that contains ClusterSecurityGroup.Name and ClusterSecurityGroup.Status subelements.  Cluster security groups are used when the cluster is not created in an Amazon Virtual Private Cloud (VPC). Clusters that are created in a VPC use VPC security groups, which are listed by the VpcSecurityGroups parameter.
        @OptionalCustomCoding<ArrayCoder<_ClusterSecurityGroupsEncoding, ClusterSecurityGroupMembership>>
        public var clusterSecurityGroups: [ClusterSecurityGroupMembership]?
        /// A value that returns the destination region and retention period that are configured for cross-region snapshot copy.
        public let clusterSnapshotCopyStatus: ClusterSnapshotCopyStatus?
        ///  The current state of the cluster. Possible values are the following:    available     available, prep-for-resize     available, resize-cleanup     cancelling-resize     creating     deleting     final-snapshot     hardware-failure     incompatible-hsm     incompatible-network     incompatible-parameters     incompatible-restore     modifying     paused     rebooting     renaming     resizing     rotating-keys     storage-full     updating-hsm
        public let clusterStatus: String?
        /// The name of the subnet group that is associated with the cluster. This parameter is valid only when the cluster is in a VPC.
        public let clusterSubnetGroupName: String?
        /// The version ID of the Amazon Redshift engine that is running on the cluster.
        public let clusterVersion: String?
        /// The certificate Amazon Resource Name (ARN) for the custom domain name.
        public let customDomainCertificateArn: String?
        /// The expiration date for the certificate associated with the custom domain name.
        public let customDomainCertificateExpiryDate: Date?
        /// The custom domain name associated with the cluster.
        public let customDomainName: String?
        public let dataTransferProgress: DataTransferProgress?
        /// The name of the initial database that was created when the cluster was created. This same name is returned for the life of the cluster. If an initial database was not specified, a database named devdev was created by default.
        public let dbName: String?
        /// The Amazon Resource Name (ARN) for the IAM role set as default for the cluster.
        public let defaultIamRoleArn: String?
        /// Describes a group of DeferredMaintenanceWindow objects.
        @OptionalCustomCoding<ArrayCoder<_DeferredMaintenanceWindowsEncoding, DeferredMaintenanceWindow>>
        public var deferredMaintenanceWindows: [DeferredMaintenanceWindow]?
        /// The status of the elastic IP (EIP) address.
        public let elasticIpStatus: ElasticIpStatus?
        /// The number of nodes that you can resize the cluster to with the elastic resize method.
        public let elasticResizeNumberOfNodeOptions: String?
        /// A boolean value that, if true, indicates that data in the cluster is encrypted at rest.
        public let encrypted: Bool?
        /// The connection endpoint.
        public let endpoint: Endpoint?
        /// An option that specifies whether to create the cluster with enhanced VPC routing enabled. To create a cluster that uses enhanced VPC routing, the cluster must be in a VPC. For more information, see Enhanced VPC Routing in the Amazon Redshift Cluster Management Guide. If this option is true, enhanced VPC routing is enabled.  Default: false
        public let enhancedVpcRouting: Bool?
        /// The date and time when the next snapshot is expected to be taken for clusters with a valid snapshot schedule and backups enabled.
        public let expectedNextSnapshotScheduleTime: Date?
        ///  The status of next expected snapshot for clusters having a valid snapshot schedule and backups enabled.  Possible values are the following:   OnTrack - The next snapshot is expected to be taken on time.    Pending - The next snapshot is pending to be taken.
        public let expectedNextSnapshotScheduleTimeStatus: String?
        /// A value that reports whether the Amazon Redshift cluster has finished applying any hardware security module (HSM) settings changes specified in a modify cluster command. Values: active, applying
        public let hsmStatus: HsmStatus?
        /// A list of Identity and Access Management (IAM) roles that can be used by the cluster to access other Amazon Web Services services.
        @OptionalCustomCoding<ArrayCoder<_IamRolesEncoding, ClusterIamRole>>
        public var iamRoles: [ClusterIamRole]?
        /// The IP address type for the cluster. Possible values are ipv4 and dualstack.
        public let ipAddressType: String?
        /// The Key Management Service (KMS) key ID of the encryption key used to encrypt data in the cluster.
        public let kmsKeyId: String?
        /// The name of the maintenance track for the cluster.
        public let maintenanceTrackName: String?
        /// The default number of days to retain a manual snapshot. If the value is -1, the snapshot is retained indefinitely. This setting doesn't change the retention period of existing snapshots. The value must be either -1 or an integer between 1 and 3,653.
        public let manualSnapshotRetentionPeriod: Int?
        /// The Amazon Resource Name (ARN) for the cluster's admin user credentials secret.
        public let masterPasswordSecretArn: String?
        /// The ID of the Key Management Service (KMS) key used to encrypt and store the cluster's admin credentials secret.
        public let masterPasswordSecretKmsKeyId: String?
        /// The admin user name for the cluster. This name is used to connect to the database that is specified in the DBName parameter.
        public let masterUsername: String?
        /// The status of a modify operation, if any, initiated for the cluster.
        public let modifyStatus: String?
        /// A boolean value that, if true, indicates that the cluster is deployed in two Availability Zones.
        public let multiAZ: String?
        /// The secondary compute unit of a cluster, if Multi-AZ deployment is turned on.
        public let multiAZSecondary: SecondaryClusterInfo?
        /// The date and time in UTC when system maintenance can begin.
        public let nextMaintenanceWindowStartTime: Date?
        /// The node type for the nodes in the cluster.
        public let nodeType: String?
        /// The number of compute nodes in the cluster.
        public let numberOfNodes: Int?
        /// Cluster operations that are waiting to be started.
        @OptionalCustomCoding<StandardArrayCoder<String>>
        public var pendingActions: [String]?
        /// A value that, if present, indicates that changes to the cluster are pending. Specific pending changes are identified by subelements.
        public let pendingModifiedValues: PendingModifiedValues?
        /// The weekly time range, in Universal Coordinated Time (UTC), during which system maintenance can occur.
        public let preferredMaintenanceWindow: String?
        /// A boolean value that, if true, indicates that the cluster can be accessed from a public network. Default: false
        public let publiclyAccessible: Bool?
        /// The status of the reserved-node exchange request. Statuses include in-progress and requested.
        public let reservedNodeExchangeStatus: ReservedNodeExchangeStatus?
        /// Returns the following:   AllowCancelResize: a boolean value indicating if the resize operation can be cancelled.   ResizeType: Returns ClassicResize
        public let resizeInfo: ResizeInfo?
        /// A value that describes the status of a cluster restore action. This parameter returns null if the cluster was not created by restoring a snapshot.
        public let restoreStatus: RestoreStatus?
        /// A unique identifier for the cluster snapshot schedule.
        public let snapshotScheduleIdentifier: String?
        /// The current state of the cluster snapshot schedule.
        public let snapshotScheduleState: ScheduleState?
        /// The list of tags for the cluster.
        @OptionalCustomCoding<ArrayCoder<_TagsEncoding, Tag>>
        public var tags: [Tag]?
        /// The total storage capacity of the cluster in megabytes.
        public let totalStorageCapacityInMegaBytes: Int64?
        /// The identifier of the VPC the cluster is in, if the cluster is in a VPC.
        public let vpcId: String?
        /// A list of Amazon Virtual Private Cloud (Amazon VPC) security groups that are associated with the cluster. This parameter is returned only if the cluster is in a VPC.
        @OptionalCustomCoding<ArrayCoder<_VpcSecurityGroupsEncoding, VpcSecurityGroupMembership>>
        public var vpcSecurityGroups: [VpcSecurityGroupMembership]?

        @inlinable
        public init(allowVersionUpgrade: Bool? = nil, aquaConfiguration: AquaConfiguration? = nil, automatedSnapshotRetentionPeriod: Int? = nil, availabilityZone: String? = nil, availabilityZoneRelocationStatus: String? = nil, clusterAvailabilityStatus: String? = nil, clusterCreateTime: Date? = nil, clusterIdentifier: String? = nil, clusterNamespaceArn: String? = nil, clusterNodes: [ClusterNode]? = nil, clusterParameterGroups: [ClusterParameterGroupStatus]? = nil, clusterPublicKey: String? = nil, clusterRevisionNumber: String? = nil, clusterSecurityGroups: [ClusterSecurityGroupMembership]? = nil, clusterSnapshotCopyStatus: ClusterSnapshotCopyStatus? = nil, clusterStatus: String? = nil, clusterSubnetGroupName: String? = nil, clusterVersion: String? = nil, customDomainCertificateArn: String? = nil, customDomainCertificateExpiryDate: Date? = nil, customDomainName: String? = nil, dataTransferProgress: DataTransferProgress? = nil, dbName: String? = nil, defaultIamRoleArn: String? = nil, deferredMaintenanceWindows: [DeferredMaintenanceWindow]? = nil, elasticIpStatus: ElasticIpStatus? = nil, elasticResizeNumberOfNodeOptions: String? = nil, encrypted: Bool? = nil, endpoint: Endpoint? = nil, enhancedVpcRouting: Bool? = nil, expectedNextSnapshotScheduleTime: Date? = nil, expectedNextSnapshotScheduleTimeStatus: String? = nil, hsmStatus: HsmStatus? = nil, iamRoles: [ClusterIamRole]? = nil, ipAddressType: String? = nil, kmsKeyId: String? = nil, maintenanceTrackName: String? = nil, manualSnapshotRetentionPeriod: Int? = nil, masterPasswordSecretArn: String? = nil, masterPasswordSecretKmsKeyId: String? = nil, masterUsername: String? = nil, modifyStatus: String? = nil, multiAZ: String? = nil, multiAZSecondary: SecondaryClusterInfo? = nil, nextMaintenanceWindowStartTime: Date? = nil, nodeType: String? = nil, numberOfNodes: Int? = nil, pendingActions: [String]? = nil, pendingModifiedValues: PendingModifiedValues? = nil, preferredMaintenanceWindow: String? = nil, publiclyAccessible: Bool? = nil, reservedNodeExchangeStatus: ReservedNodeExchangeStatus? = nil, resizeInfo: ResizeInfo? = nil, restoreStatus: RestoreStatus? = nil, snapshotScheduleIdentifier: String? = nil, snapshotScheduleState: ScheduleState? = nil, tags: [Tag]? = nil, totalStorageCapacityInMegaBytes: Int64? = nil, vpcId: String? = nil, vpcSecurityGroups: [VpcSecurityGroupMembership]? = nil) {
            self.allowVersionUpgrade = allowVersionUpgrade
            self.aquaConfiguration = aquaConfiguration
            self.automatedSnapshotRetentionPeriod = automatedSnapshotRetentionPeriod
            self.availabilityZone = availabilityZone
            self.availabilityZoneRelocationStatus = availabilityZoneRelocationStatus
            self.clusterAvailabilityStatus = clusterAvailabilityStatus
            self.clusterCreateTime = clusterCreateTime
            self.clusterIdentifier = clusterIdentifier
            self.clusterNamespaceArn = clusterNamespaceArn
            self.clusterNodes = clusterNodes
            self.clusterParameterGroups = clusterParameterGroups
            self.clusterPublicKey = clusterPublicKey
            self.clusterRevisionNumber = clusterRevisionNumber
            self.clusterSecurityGroups = clusterSecurityGroups
            self.clusterSnapshotCopyStatus = clusterSnapshotCopyStatus
            self.clusterStatus = clusterStatus
            self.clusterSubnetGroupName = clusterSubnetGroupName
            self.clusterVersion = clusterVersion
            self.customDomainCertificateArn = customDomainCertificateArn
            self.customDomainCertificateExpiryDate = customDomainCertificateExpiryDate
            self.customDomainName = customDomainName
            self.dataTransferProgress = dataTransferProgress
            self.dbName = dbName
            self.defaultIamRoleArn = defaultIamRoleArn
            self.deferredMaintenanceWindows = deferredMaintenanceWindows
            self.elasticIpStatus = elasticIpStatus
            self.elasticResizeNumberOfNodeOptions = elasticResizeNumberOfNodeOptions
            self.encrypted = encrypted
            self.endpoint = endpoint
            self.enhancedVpcRouting = enhancedVpcRouting
            self.expectedNextSnapshotScheduleTime = expectedNextSnapshotScheduleTime
            self.expectedNextSnapshotScheduleTimeStatus = expectedNextSnapshotScheduleTimeStatus
            self.hsmStatus = hsmStatus
            self.iamRoles = iamRoles
            self.ipAddressType = ipAddressType
            self.kmsKeyId = kmsKeyId
            self.maintenanceTrackName = maintenanceTrackName
            self.manualSnapshotRetentionPeriod = manualSnapshotRetentionPeriod
            self.masterPasswordSecretArn = masterPasswordSecretArn
            self.masterPasswordSecretKmsKeyId = masterPasswordSecretKmsKeyId
            self.masterUsername = masterUsername
            self.modifyStatus = modifyStatus
            self.multiAZ = multiAZ
            self.multiAZSecondary = multiAZSecondary
            self.nextMaintenanceWindowStartTime = nextMaintenanceWindowStartTime
            self.nodeType = nodeType
            self.numberOfNodes = numberOfNodes
            self.pendingActions = pendingActions
            self.pendingModifiedValues = pendingModifiedValues
            self.preferredMaintenanceWindow = preferredMaintenanceWindow
            self.publiclyAccessible = publiclyAccessible
            self.reservedNodeExchangeStatus = reservedNodeExchangeStatus
            self.resizeInfo = resizeInfo
            self.restoreStatus = restoreStatus
            self.snapshotScheduleIdentifier = snapshotScheduleIdentifier
            self.snapshotScheduleState = snapshotScheduleState
            self.tags = tags
            self.totalStorageCapacityInMegaBytes = totalStorageCapacityInMegaBytes
            self.vpcId = vpcId
            self.vpcSecurityGroups = vpcSecurityGroups
        }

        private enum CodingKeys: String, CodingKey {
            case allowVersionUpgrade = "AllowVersionUpgrade"
            case aquaConfiguration = "AquaConfiguration"
            case automatedSnapshotRetentionPeriod = "AutomatedSnapshotRetentionPeriod"
            case availabilityZone = "AvailabilityZone"
            case availabilityZoneRelocationStatus = "AvailabilityZoneRelocationStatus"
            case clusterAvailabilityStatus = "ClusterAvailabilityStatus"
            case clusterCreateTime = "ClusterCreateTime"
            case clusterIdentifier = "ClusterIdentifier"
            case clusterNamespaceArn = "ClusterNamespaceArn"
            case clusterNodes = "ClusterNodes"
            case clusterParameterGroups = "ClusterParameterGroups"
            case clusterPublicKey = "ClusterPublicKey"
            case clusterRevisionNumber = "ClusterRevisionNumber"
            case clusterSecurityGroups = "ClusterSecurityGroups"
            case clusterSnapshotCopyStatus = "ClusterSnapshotCopyStatus"
            case clusterStatus = "ClusterStatus"
            case clusterSubnetGroupName = "ClusterSubnetGroupName"
            case clusterVersion = "ClusterVersion"
            case customDomainCertificateArn = "CustomDomainCertificateArn"
            case customDomainCertificateExpiryDate = "CustomDomainCertificateExpiryDate"
            case customDomainName = "CustomDomainName"
            case dataTransferProgress = "DataTransferProgress"
            case dbName = "DBName"
            case defaultIamRoleArn = "DefaultIamRoleArn"
            case deferredMaintenanceWindows = "DeferredMaintenanceWindows"
            case elasticIpStatus = "ElasticIpStatus"
            case elasticResizeNumberOfNodeOptions = "ElasticResizeNumberOfNodeOptions"
            case encrypted = "Encrypted"
            case endpoint = "Endpoint"
            case enhancedVpcRouting = "EnhancedVpcRouting"
            case expectedNextSnapshotScheduleTime = "ExpectedNextSnapshotScheduleTime"
            case expectedNextSnapshotScheduleTimeStatus = "ExpectedNextSnapshotScheduleTimeStatus"
            case hsmStatus = "HsmStatus"
            case iamRoles = "IamRoles"
            case ipAddressType = "IpAddressType"
            case kmsKeyId = "KmsKeyId"
            case maintenanceTrackName = "MaintenanceTrackName"
            case manualSnapshotRetentionPeriod = "ManualSnapshotRetentionPeriod"
            case masterPasswordSecretArn = "MasterPasswordSecretArn"
            case masterPasswordSecretKmsKeyId = "MasterPasswordSecretKmsKeyId"
            case masterUsername = "MasterUsername"
            case modifyStatus = "ModifyStatus"
            case multiAZ = "MultiAZ"
            case multiAZSecondary = "MultiAZSecondary"
            case nextMaintenanceWindowStartTime = "NextMaintenanceWindowStartTime"
            case nodeType = "NodeType"
            case numberOfNodes = "NumberOfNodes"
            case pendingActions = "PendingActions"
            case pendingModifiedValues = "PendingModifiedValues"
            case preferredMaintenanceWindow = "PreferredMaintenanceWindow"
            case publiclyAccessible = "PubliclyAccessible"
            case reservedNodeExchangeStatus = "ReservedNodeExchangeStatus"
            case resizeInfo = "ResizeInfo"
            case restoreStatus = "RestoreStatus"
            case snapshotScheduleIdentifier = "SnapshotScheduleIdentifier"
            case snapshotScheduleState = "SnapshotScheduleState"
            case tags = "Tags"
            case totalStorageCapacityInMegaBytes = "TotalStorageCapacityInMegaBytes"
            case vpcId = "VpcId"
            case vpcSecurityGroups = "VpcSecurityGroups"
        }
    }

    public struct ClusterAssociatedToSchedule: AWSDecodableShape {
        public let clusterIdentifier: String?
        public let scheduleAssociationState: ScheduleState?

        @inlinable
        public init(clusterIdentifier: String? = nil, scheduleAssociationState: ScheduleState? = nil) {
            self.clusterIdentifier = clusterIdentifier
            self.scheduleAssociationState = scheduleAssociationState
        }

        private enum CodingKeys: String, CodingKey {
            case clusterIdentifier = "ClusterIdentifier"
            case scheduleAssociationState = "ScheduleAssociationState"
        }
    }

    public struct ClusterCredentials: AWSDecodableShape {
        /// A temporary password that authorizes the user name returned by DbUser to log on to the database DbName.
        public let dbPassword: String?
        /// A database user name that is authorized to log on to the database DbName using the password DbPassword. If the specified DbUser exists in the database, the new user name has the same database permissions as the the user named in DbUser. By default, the user is added to PUBLIC. If the DbGroups parameter is specifed, DbUser is added to the listed groups for any sessions created using these credentials.
        public let dbUser: String?
        /// The date and time the password in DbPassword expires.
        public let expiration: Date?

        @inlinable
        public init(dbPassword: String? = nil, dbUser: String? = nil, expiration: Date? = nil) {
            self.dbPassword = dbPassword
            self.dbUser = dbUser
            self.expiration = expiration
        }

        private enum CodingKeys: String, CodingKey {
            case dbPassword = "DbPassword"
            case dbUser = "DbUser"
            case expiration = "Expiration"
        }
    }

    public struct ClusterDbRevision: AWSDecodableShape {
        public struct _RevisionTargetsEncoding: ArrayCoderProperties { public static let member = "RevisionTarget" }

        /// The unique identifier of the cluster.
        public let clusterIdentifier: String?
        /// A string representing the current cluster version.
        public let currentDatabaseRevision: String?
        /// The date on which the database revision was released.
        public let databaseRevisionReleaseDate: Date?
        /// A list of RevisionTarget objects, where each object describes the database revision that a cluster can be updated to.
        @OptionalCustomCoding<ArrayCoder<_RevisionTargetsEncoding, RevisionTarget>>
        public var revisionTargets: [RevisionTarget]?

        @inlinable
        public init(clusterIdentifier: String? = nil, currentDatabaseRevision: String? = nil, databaseRevisionReleaseDate: Date? = nil, revisionTargets: [RevisionTarget]? = nil) {
            self.clusterIdentifier = clusterIdentifier
            self.currentDatabaseRevision = currentDatabaseRevision
            self.databaseRevisionReleaseDate = databaseRevisionReleaseDate
            self.revisionTargets = revisionTargets
        }

        private enum CodingKeys: String, CodingKey {
            case clusterIdentifier = "ClusterIdentifier"
            case currentDatabaseRevision = "CurrentDatabaseRevision"
            case databaseRevisionReleaseDate = "DatabaseRevisionReleaseDate"
            case revisionTargets = "RevisionTargets"
        }
    }

    public struct ClusterDbRevisionsMessage: AWSDecodableShape {
        public struct _ClusterDbRevisionsEncoding: ArrayCoderProperties { public static let member = "ClusterDbRevision" }

        /// A list of revisions.
        @OptionalCustomCoding<ArrayCoder<_ClusterDbRevisionsEncoding, ClusterDbRevision>>
        public var clusterDbRevisions: [ClusterDbRevision]?
        /// A string representing the starting point for the next set of revisions. If a value is returned in a response, you can retrieve the next set of revisions by providing the value in the marker parameter and retrying the command. If the marker field is empty, all revisions have already been returned.
        public let marker: String?

        @inlinable
        public init(clusterDbRevisions: [ClusterDbRevision]? = nil, marker: String? = nil) {
            self.clusterDbRevisions = clusterDbRevisions
            self.marker = marker
        }

        private enum CodingKeys: String, CodingKey {
            case clusterDbRevisions = "ClusterDbRevisions"
            case marker = "Marker"
        }
    }

    public struct ClusterExtendedCredentials: AWSDecodableShape {
        /// A temporary password that you provide when you connect to a database.
        public let dbPassword: String?
        /// A database user name that you provide when you connect to a database. The database user is mapped 1:1 to the source IAM identity.
        public let dbUser: String?
        /// The time (UTC) when the temporary password expires. After this timestamp, a log in with the temporary password fails.
        public let expiration: Date?
        /// Reserved for future use.
        public let nextRefreshTime: Date?

        @inlinable
        public init(dbPassword: String? = nil, dbUser: String? = nil, expiration: Date? = nil, nextRefreshTime: Date? = nil) {
            self.dbPassword = dbPassword
            self.dbUser = dbUser
            self.expiration = expiration
            self.nextRefreshTime = nextRefreshTime
        }

        private enum CodingKeys: String, CodingKey {
            case dbPassword = "DbPassword"
            case dbUser = "DbUser"
            case expiration = "Expiration"
            case nextRefreshTime = "NextRefreshTime"
        }
    }

    public struct ClusterIamRole: AWSDecodableShape {
        /// A value that describes the status of the IAM role's association with an Amazon Redshift cluster. The following are possible statuses and descriptions.    in-sync: The role is available for use by the cluster.    adding: The role is in the process of being associated with the cluster.    removing: The role is in the process of being disassociated with the cluster.
        public let applyStatus: String?
        /// The Amazon Resource Name (ARN) of the IAM role, for example, arn:aws:iam::123456789012:role/RedshiftCopyUnload.
        public let iamRoleArn: String?

        @inlinable
        public init(applyStatus: String? = nil, iamRoleArn: String? = nil) {
            self.applyStatus = applyStatus
            self.iamRoleArn = iamRoleArn
        }

        private enum CodingKeys: String, CodingKey {
            case applyStatus = "ApplyStatus"
            case iamRoleArn = "IamRoleArn"
        }
    }

    public struct ClusterNode: AWSDecodableShape {
        /// Whether the node is a leader node or a compute node.
        public let nodeRole: String?
        /// The private IP address of a node within a cluster.
        public let privateIPAddress: String?
        /// The public IP address of a node within a cluster.
        public let publicIPAddress: String?

        @inlinable
        public init(nodeRole: String? = nil, privateIPAddress: String? = nil, publicIPAddress: String? = nil) {
            self.nodeRole = nodeRole
            self.privateIPAddress = privateIPAddress
            self.publicIPAddress = publicIPAddress
        }

        private enum CodingKeys: String, CodingKey {
            case nodeRole = "NodeRole"
            case privateIPAddress = "PrivateIPAddress"
            case publicIPAddress = "PublicIPAddress"
        }
    }

    public struct ClusterParameterGroup: AWSDecodableShape {
        public struct _TagsEncoding: ArrayCoderProperties { public static let member = "Tag" }

        /// The description of the parameter group.
        public let description: String?
        /// The name of the cluster parameter group family that this cluster parameter group is compatible with.
        public let parameterGroupFamily: String?
        /// The name of the cluster parameter group.
        public let parameterGroupName: String?
        /// The list of tags for the cluster parameter group.
        @OptionalCustomCoding<ArrayCoder<_TagsEncoding, Tag>>
        public var tags: [Tag]?

        @inlinable
        public init(description: String? = nil, parameterGroupFamily: String? = nil, parameterGroupName: String? = nil, tags: [Tag]? = nil) {
            self.description = description
            self.parameterGroupFamily = parameterGroupFamily
            self.parameterGroupName = parameterGroupName
            self.tags = tags
        }

        private enum CodingKeys: String, CodingKey {
            case description = "Description"
            case parameterGroupFamily = "ParameterGroupFamily"
            case parameterGroupName = "ParameterGroupName"
            case tags = "Tags"
        }
    }

    public struct ClusterParameterGroupDetails: AWSDecodableShape {
        public struct _ParametersEncoding: ArrayCoderProperties { public static let member = "Parameter" }

        /// A value that indicates the starting point for the next set of response records in a subsequent request. If a value is returned in a response, you can retrieve the next set of records by providing this returned marker value in the Marker parameter and retrying the command. If the Marker field is empty, all response records have been retrieved for the request.
        public let marker: String?
        /// A list of Parameter instances. Each instance lists the parameters of one cluster parameter group.
        @OptionalCustomCoding<ArrayCoder<_ParametersEncoding, Parameter>>
        public var parameters: [Parameter]?

        @inlinable
        public init(marker: String? = nil, parameters: [Parameter]? = nil) {
            self.marker = marker
            self.parameters = parameters
        }

        private enum CodingKeys: String, CodingKey {
            case marker = "Marker"
            case parameters = "Parameters"
        }
    }

    public struct ClusterParameterGroupNameMessage: AWSDecodableShape {
        /// The name of the cluster parameter group.
        public let parameterGroupName: String?
        /// The status of the parameter group. For example, if you made a change to a parameter group name-value pair, then the change could be pending a reboot of an associated cluster.
        public let parameterGroupStatus: String?

        @inlinable
        public init(parameterGroupName: String? = nil, parameterGroupStatus: String? = nil) {
            self.parameterGroupName = parameterGroupName
            self.parameterGroupStatus = parameterGroupStatus
        }

        private enum CodingKeys: String, CodingKey {
            case parameterGroupName = "ParameterGroupName"
            case parameterGroupStatus = "ParameterGroupStatus"
        }
    }

    public struct ClusterParameterGroupStatus: AWSDecodableShape {
        /// The list of parameter statuses.
        /// For more information about parameters and parameter groups, go to
        /// Amazon Redshift Parameter Groups
        /// in the Amazon Redshift Cluster Management Guide.
        @OptionalCustomCoding<StandardArrayCoder<ClusterParameterStatus>>
        public var clusterParameterStatusList: [ClusterParameterStatus]?
        /// The status of parameter updates.
        public let parameterApplyStatus: String?
        /// The name of the cluster parameter group.
        public let parameterGroupName: String?

        @inlinable
        public init(clusterParameterStatusList: [ClusterParameterStatus]? = nil, parameterApplyStatus: String? = nil, parameterGroupName: String? = nil) {
            self.clusterParameterStatusList = clusterParameterStatusList
            self.parameterApplyStatus = parameterApplyStatus
            self.parameterGroupName = parameterGroupName
        }

        private enum CodingKeys: String, CodingKey {
            case clusterParameterStatusList = "ClusterParameterStatusList"
            case parameterApplyStatus = "ParameterApplyStatus"
            case parameterGroupName = "ParameterGroupName"
        }
    }

    public struct ClusterParameterGroupsMessage: AWSDecodableShape {
        public struct _ParameterGroupsEncoding: ArrayCoderProperties { public static let member = "ClusterParameterGroup" }

        /// A value that indicates the starting point for the next set of response records in a subsequent request. If a value is returned in a response, you can retrieve the next set of records by providing this returned marker value in the Marker parameter and retrying the command. If the Marker field is empty, all response records have been retrieved for the request.
        public let marker: String?
        /// A list of ClusterParameterGroup instances. Each instance describes one cluster parameter group.
        @OptionalCustomCoding<ArrayCoder<_ParameterGroupsEncoding, ClusterParameterGroup>>
        public var parameterGroups: [ClusterParameterGroup]?

        @inlinable
        public init(marker: String? = nil, parameterGroups: [ClusterParameterGroup]? = nil) {
            self.marker = marker
            self.parameterGroups = parameterGroups
        }

        private enum CodingKeys: String, CodingKey {
            case marker = "Marker"
            case parameterGroups = "ParameterGroups"
        }
    }

    public struct ClusterParameterStatus: AWSDecodableShape {
        /// The error that prevented the parameter from being applied to the database.
        public let parameterApplyErrorDescription: String?
        /// The status of the parameter that indicates whether the parameter is in sync with the database, waiting for a cluster reboot, or encountered an error when being applied. The following are possible statuses and descriptions.    in-sync: The parameter value is in sync with the database.    pending-reboot: The parameter value will be applied after the cluster reboots.    applying: The parameter value is being applied to the database.    invalid-parameter: Cannot apply the parameter value because it has an invalid value or syntax.    apply-deferred: The parameter contains static property changes. The changes are deferred until the cluster reboots.    apply-error: Cannot connect to the cluster. The parameter change will be applied after the cluster reboots.    unknown-error: Cannot apply the parameter change right now. The change will be applied after the cluster reboots.
        public let parameterApplyStatus: String?
        /// The name of the parameter.
        public let parameterName: String?

        @inlinable
        public init(parameterApplyErrorDescription: String? = nil, parameterApplyStatus: String? = nil, parameterName: String? = nil) {
            self.parameterApplyErrorDescription = parameterApplyErrorDescription
            self.parameterApplyStatus = parameterApplyStatus
            self.parameterName = parameterName
        }

        private enum CodingKeys: String, CodingKey {
            case parameterApplyErrorDescription = "ParameterApplyErrorDescription"
            case parameterApplyStatus = "ParameterApplyStatus"
            case parameterName = "ParameterName"
        }
    }

    public struct ClusterSecurityGroup: AWSDecodableShape {
        public struct _EC2SecurityGroupsEncoding: ArrayCoderProperties { public static let member = "EC2SecurityGroup" }
        public struct _IPRangesEncoding: ArrayCoderProperties { public static let member = "IPRange" }
        public struct _TagsEncoding: ArrayCoderProperties { public static let member = "Tag" }

        /// The name of the cluster security group to which the operation was applied.
        public let clusterSecurityGroupName: String?
        /// A description of the security group.
        public let description: String?
        /// A list of EC2 security groups that are permitted to access clusters associated with this cluster security group.
        @OptionalCustomCoding<ArrayCoder<_EC2SecurityGroupsEncoding, EC2SecurityGroup>>
        public var ec2SecurityGroups: [EC2SecurityGroup]?
        /// A list of IP ranges (CIDR blocks) that are permitted to access clusters associated with this cluster security group.
        @OptionalCustomCoding<ArrayCoder<_IPRangesEncoding, IPRange>>
        public var ipRanges: [IPRange]?
        /// The list of tags for the cluster security group.
        @OptionalCustomCoding<ArrayCoder<_TagsEncoding, Tag>>
        public var tags: [Tag]?

        @inlinable
        public init(clusterSecurityGroupName: String? = nil, description: String? = nil, ec2SecurityGroups: [EC2SecurityGroup]? = nil, ipRanges: [IPRange]? = nil, tags: [Tag]? = nil) {
            self.clusterSecurityGroupName = clusterSecurityGroupName
            self.description = description
            self.ec2SecurityGroups = ec2SecurityGroups
            self.ipRanges = ipRanges
            self.tags = tags
        }

        private enum CodingKeys: String, CodingKey {
            case clusterSecurityGroupName = "ClusterSecurityGroupName"
            case description = "Description"
            case ec2SecurityGroups = "EC2SecurityGroups"
            case ipRanges = "IPRanges"
            case tags = "Tags"
        }
    }

    public struct ClusterSecurityGroupMembership: AWSDecodableShape {
        /// The name of the cluster security group.
        public let clusterSecurityGroupName: String?
        /// The status of the cluster security group.
        public let status: String?

        @inlinable
        public init(clusterSecurityGroupName: String? = nil, status: String? = nil) {
            self.clusterSecurityGroupName = clusterSecurityGroupName
            self.status = status
        }

        private enum CodingKeys: String, CodingKey {
            case clusterSecurityGroupName = "ClusterSecurityGroupName"
            case status = "Status"
        }
    }

    public struct ClusterSecurityGroupMessage: AWSDecodableShape {
        public struct _ClusterSecurityGroupsEncoding: ArrayCoderProperties { public static let member = "ClusterSecurityGroup" }

        /// A list of ClusterSecurityGroup instances.
        @OptionalCustomCoding<ArrayCoder<_ClusterSecurityGroupsEncoding, ClusterSecurityGroup>>
        public var clusterSecurityGroups: [ClusterSecurityGroup]?
        /// A value that indicates the starting point for the next set of response records in a subsequent request. If a value is returned in a response, you can retrieve the next set of records by providing this returned marker value in the Marker parameter and retrying the command. If the Marker field is empty, all response records have been retrieved for the request.
        public let marker: String?

        @inlinable
        public init(clusterSecurityGroups: [ClusterSecurityGroup]? = nil, marker: String? = nil) {
            self.clusterSecurityGroups = clusterSecurityGroups
            self.marker = marker
        }

        private enum CodingKeys: String, CodingKey {
            case clusterSecurityGroups = "ClusterSecurityGroups"
            case marker = "Marker"
        }
    }

    public struct ClusterSnapshotCopyStatus: AWSDecodableShape {
        /// The destination region that snapshots are automatically copied to when cross-region snapshot copy is enabled.
        public let destinationRegion: String?
        /// The number of days that automated snapshots are retained in the destination region after they are copied from a source region. If the value is -1, the manual snapshot is retained indefinitely.  The value must be either -1 or an integer between 1 and 3,653.
        public let manualSnapshotRetentionPeriod: Int?
        /// The number of days that automated snapshots are retained in the destination region after they are copied from a source region.
        public let retentionPeriod: Int64?
        /// The name of the snapshot copy grant.
        public let snapshotCopyGrantName: String?

        @inlinable
        public init(destinationRegion: String? = nil, manualSnapshotRetentionPeriod: Int? = nil, retentionPeriod: Int64? = nil, snapshotCopyGrantName: String? = nil) {
            self.destinationRegion = destinationRegion
            self.manualSnapshotRetentionPeriod = manualSnapshotRetentionPeriod
            self.retentionPeriod = retentionPeriod
            self.snapshotCopyGrantName = snapshotCopyGrantName
        }

        private enum CodingKeys: String, CodingKey {
            case destinationRegion = "DestinationRegion"
            case manualSnapshotRetentionPeriod = "ManualSnapshotRetentionPeriod"
            case retentionPeriod = "RetentionPeriod"
            case snapshotCopyGrantName = "SnapshotCopyGrantName"
        }
    }

    public struct ClusterSubnetGroup: AWSDecodableShape {
        public struct _SubnetsEncoding: ArrayCoderProperties { public static let member = "Subnet" }
        public struct _SupportedClusterIpAddressTypesEncoding: ArrayCoderProperties { public static let member = "item" }
        public struct _TagsEncoding: ArrayCoderProperties { public static let member = "Tag" }

        /// The name of the cluster subnet group.
        public let clusterSubnetGroupName: String?
        /// The description of the cluster subnet group.
        public let description: String?
        /// The status of the cluster subnet group. Possible values are Complete, Incomplete and Invalid.
        public let subnetGroupStatus: String?
        /// A list of the VPC Subnet elements.
        @OptionalCustomCoding<ArrayCoder<_SubnetsEncoding, Subnet>>
        public var subnets: [Subnet]?
        /// The IP address types supported by this cluster subnet group. Possible values are ipv4 and dualstack.
        @OptionalCustomCoding<ArrayCoder<_SupportedClusterIpAddressTypesEncoding, String>>
        public var supportedClusterIpAddressTypes: [String]?
        /// The list of tags for the cluster subnet group.
        @OptionalCustomCoding<ArrayCoder<_TagsEncoding, Tag>>
        public var tags: [Tag]?
        /// The VPC ID of the cluster subnet group.
        public let vpcId: String?

        @inlinable
        public init(clusterSubnetGroupName: String? = nil, description: String? = nil, subnetGroupStatus: String? = nil, subnets: [Subnet]? = nil, supportedClusterIpAddressTypes: [String]? = nil, tags: [Tag]? = nil, vpcId: String? = nil) {
            self.clusterSubnetGroupName = clusterSubnetGroupName
            self.description = description
            self.subnetGroupStatus = subnetGroupStatus
            self.subnets = subnets
            self.supportedClusterIpAddressTypes = supportedClusterIpAddressTypes
            self.tags = tags
            self.vpcId = vpcId
        }

        private enum CodingKeys: String, CodingKey {
            case clusterSubnetGroupName = "ClusterSubnetGroupName"
            case description = "Description"
            case subnetGroupStatus = "SubnetGroupStatus"
            case subnets = "Subnets"
            case supportedClusterIpAddressTypes = "SupportedClusterIpAddressTypes"
            case tags = "Tags"
            case vpcId = "VpcId"
        }
    }

    public struct ClusterSubnetGroupMessage: AWSDecodableShape {
        public struct _ClusterSubnetGroupsEncoding: ArrayCoderProperties { public static let member = "ClusterSubnetGroup" }

        /// A list of ClusterSubnetGroup instances.
        @OptionalCustomCoding<ArrayCoder<_ClusterSubnetGroupsEncoding, ClusterSubnetGroup>>
        public var clusterSubnetGroups: [ClusterSubnetGroup]?
        /// A value that indicates the starting point for the next set of response records in a subsequent request. If a value is returned in a response, you can retrieve the next set of records by providing this returned marker value in the Marker parameter and retrying the command. If the Marker field is empty, all response records have been retrieved for the request.
        public let marker: String?

        @inlinable
        public init(clusterSubnetGroups: [ClusterSubnetGroup]? = nil, marker: String? = nil) {
            self.clusterSubnetGroups = clusterSubnetGroups
            self.marker = marker
        }

        private enum CodingKeys: String, CodingKey {
            case clusterSubnetGroups = "ClusterSubnetGroups"
            case marker = "Marker"
        }
    }

    public struct ClusterVersion: AWSDecodableShape {
        /// The name of the cluster parameter group family for the cluster.
        public let clusterParameterGroupFamily: String?
        /// The version number used by the cluster.
        public let clusterVersion: String?
        /// The description of the cluster version.
        public let description: String?

        @inlinable
        public init(clusterParameterGroupFamily: String? = nil, clusterVersion: String? = nil, description: String? = nil) {
            self.clusterParameterGroupFamily = clusterParameterGroupFamily
            self.clusterVersion = clusterVersion
            self.description = description
        }

        private enum CodingKeys: String, CodingKey {
            case clusterParameterGroupFamily = "ClusterParameterGroupFamily"
            case clusterVersion = "ClusterVersion"
            case description = "Description"
        }
    }

    public struct ClusterVersionsMessage: AWSDecodableShape {
        public struct _ClusterVersionsEncoding: ArrayCoderProperties { public static let member = "ClusterVersion" }

        /// A list of Version elements.
        @OptionalCustomCoding<ArrayCoder<_ClusterVersionsEncoding, ClusterVersion>>
        public var clusterVersions: [ClusterVersion]?
        /// A value that indicates the starting point for the next set of response records in a subsequent request. If a value is returned in a response, you can retrieve the next set of records by providing this returned marker value in the Marker parameter and retrying the command. If the Marker field is empty, all response records have been retrieved for the request.
        public let marker: String?

        @inlinable
        public init(clusterVersions: [ClusterVersion]? = nil, marker: String? = nil) {
            self.clusterVersions = clusterVersions
            self.marker = marker
        }

        private enum CodingKeys: String, CodingKey {
            case clusterVersions = "ClusterVersions"
            case marker = "Marker"
        }
    }

    public struct ClustersMessage: AWSDecodableShape {
        public struct _ClustersEncoding: ArrayCoderProperties { public static let member = "Cluster" }

        /// A list of Cluster objects, where each object describes one cluster.
        @OptionalCustomCoding<ArrayCoder<_ClustersEncoding, Cluster>>
        public var clusters: [Cluster]?
        /// A value that indicates the starting point for the next set of response records in a subsequent request. If a value is returned in a response, you can retrieve the next set of records by providing this returned marker value in the Marker parameter and retrying the command. If the Marker field is empty, all response records have been retrieved for the request.
        public let marker: String?

        @inlinable
        public init(clusters: [Cluster]? = nil, marker: String? = nil) {
            self.clusters = clusters
            self.marker = marker
        }

        private enum CodingKeys: String, CodingKey {
            case clusters = "Clusters"
            case marker = "Marker"
        }
    }

    public struct CopyClusterSnapshotMessage: AWSEncodableShape {
        /// The number of days that a manual snapshot is retained. If the value is -1, the manual snapshot is retained indefinitely.  The value must be either -1 or an integer between 1 and 3,653. The default value is -1.
        public let manualSnapshotRetentionPeriod: Int?
        /// The identifier of the cluster the source snapshot was created from. This parameter is required if your IAM user has a policy containing a snapshot resource element that specifies anything other than * for the cluster name. Constraints:   Must be the identifier for a valid cluster.
        public let sourceSnapshotClusterIdentifier: String?
        /// The identifier for the source snapshot. Constraints:   Must be the identifier for a valid automated snapshot whose state is available.
        public let sourceSnapshotIdentifier: String?
        /// The identifier given to the new manual snapshot. Constraints:   Cannot be null, empty, or blank.   Must contain from 1 to 255 alphanumeric characters or hyphens.   First character must be a letter.   Cannot end with a hyphen or contain two consecutive hyphens.   Must be unique for the Amazon Web Services account that is making the request.
        public let targetSnapshotIdentifier: String?

        @inlinable
        public init(manualSnapshotRetentionPeriod: Int? = nil, sourceSnapshotClusterIdentifier: String? = nil, sourceSnapshotIdentifier: String? = nil, targetSnapshotIdentifier: String? = nil) {
            self.manualSnapshotRetentionPeriod = manualSnapshotRetentionPeriod
            self.sourceSnapshotClusterIdentifier = sourceSnapshotClusterIdentifier
            self.sourceSnapshotIdentifier = sourceSnapshotIdentifier
            self.targetSnapshotIdentifier = targetSnapshotIdentifier
        }

        public func validate(name: String) throws {
            try self.validate(self.sourceSnapshotClusterIdentifier, name: "sourceSnapshotClusterIdentifier", parent: name, max: 2147483647)
            try self.validate(self.sourceSnapshotIdentifier, name: "sourceSnapshotIdentifier", parent: name, max: 2147483647)
            try self.validate(self.targetSnapshotIdentifier, name: "targetSnapshotIdentifier", parent: name, max: 2147483647)
        }

        private enum CodingKeys: String, CodingKey {
            case manualSnapshotRetentionPeriod = "ManualSnapshotRetentionPeriod"
            case sourceSnapshotClusterIdentifier = "SourceSnapshotClusterIdentifier"
            case sourceSnapshotIdentifier = "SourceSnapshotIdentifier"
            case targetSnapshotIdentifier = "TargetSnapshotIdentifier"
        }
    }

    public struct CopyClusterSnapshotResult: AWSDecodableShape {
        public let snapshot: Snapshot?

        @inlinable
        public init(snapshot: Snapshot? = nil) {
            self.snapshot = snapshot
        }

        private enum CodingKeys: String, CodingKey {
            case snapshot = "Snapshot"
        }
    }

    public struct CreateAuthenticationProfileMessage: AWSEncodableShape {
        /// The content of the authentication profile in JSON format.  The maximum length of the JSON string is determined by a quota for your account.
        public let authenticationProfileContent: String?
        /// The name of the authentication profile to be created.
        public let authenticationProfileName: String?

        @inlinable
        public init(authenticationProfileContent: String? = nil, authenticationProfileName: String? = nil) {
            self.authenticationProfileContent = authenticationProfileContent
            self.authenticationProfileName = authenticationProfileName
        }

        public func validate(name: String) throws {
            try self.validate(self.authenticationProfileContent, name: "authenticationProfileContent", parent: name, max: 2147483647)
            try self.validate(self.authenticationProfileName, name: "authenticationProfileName", parent: name, max: 63)
            try self.validate(self.authenticationProfileName, name: "authenticationProfileName", parent: name, pattern: "^[a-zA-Z0-9\\-]+$")
        }

        private enum CodingKeys: String, CodingKey {
            case authenticationProfileContent = "AuthenticationProfileContent"
            case authenticationProfileName = "AuthenticationProfileName"
        }
    }

    public struct CreateAuthenticationProfileResult: AWSDecodableShape {
        /// The content of the authentication profile in JSON format.
        public let authenticationProfileContent: String?
        /// The name of the authentication profile that was created.
        public let authenticationProfileName: String?

        @inlinable
        public init(authenticationProfileContent: String? = nil, authenticationProfileName: String? = nil) {
            self.authenticationProfileContent = authenticationProfileContent
            self.authenticationProfileName = authenticationProfileName
        }

        private enum CodingKeys: String, CodingKey {
            case authenticationProfileContent = "AuthenticationProfileContent"
            case authenticationProfileName = "AuthenticationProfileName"
        }
    }

    public struct CreateClusterMessage: AWSEncodableShape {
        public struct _ClusterSecurityGroupsEncoding: ArrayCoderProperties { public static let member = "ClusterSecurityGroupName" }
        public struct _IamRolesEncoding: ArrayCoderProperties { public static let member = "IamRoleArn" }
        public struct _TagsEncoding: ArrayCoderProperties { public static let member = "Tag" }
        public struct _VpcSecurityGroupIdsEncoding: ArrayCoderProperties { public static let member = "VpcSecurityGroupId" }

        /// Reserved.
        public let additionalInfo: String?
        /// If true, major version upgrades can be applied during the maintenance window to the Amazon Redshift engine that is running on the cluster. When a new major version of the Amazon Redshift engine is released, you can request that the service automatically apply upgrades during the maintenance window to the Amazon Redshift engine that is running on your cluster. Default: true
        public let allowVersionUpgrade: Bool?
        /// This parameter is retired. It does not set the AQUA configuration status. Amazon Redshift automatically determines whether to use AQUA (Advanced Query Accelerator).
        public let aquaConfigurationStatus: AquaConfigurationStatus?
        /// The number of days that automated snapshots are retained. If the value is 0, automated snapshots are disabled. Even if automated snapshots are disabled, you can still create manual snapshots when you want with CreateClusterSnapshot.  You can't disable automated snapshots for RA3 node types. Set the automated retention period from 1-35 days. Default: 1  Constraints: Must be a value from 0 to 35.
        public let automatedSnapshotRetentionPeriod: Int?
        /// The EC2 Availability Zone (AZ) in which you want Amazon Redshift to provision the cluster. For example, if you have several EC2 instances running in a specific Availability Zone, then you might want the cluster to be provisioned in the same zone in order to decrease network latency. Default: A random, system-chosen Availability Zone in the region that is specified by the endpoint. Example: us-east-2d  Constraint: The specified Availability Zone must be in the same region as the current endpoint.
        public let availabilityZone: String?
        /// The option to enable relocation for an Amazon Redshift cluster between Availability Zones after the cluster is created.
        public let availabilityZoneRelocation: Bool?
        /// A unique identifier for the cluster. You use this identifier to refer to the cluster for any subsequent cluster operations such as deleting or modifying. The identifier also appears in the Amazon Redshift console. Constraints:   Must contain from 1 to 63 alphanumeric characters or hyphens.   Alphabetic characters must be lowercase.   First character must be a letter.   Cannot end with a hyphen or contain two consecutive hyphens.   Must be unique for all clusters within an Amazon Web Services account.   Example: myexamplecluster
        public let clusterIdentifier: String?
        /// The name of the parameter group to be associated with this cluster. Default: The default Amazon Redshift cluster parameter group. For information about the default parameter group, go to Working with Amazon Redshift Parameter Groups  Constraints:   Must be 1 to 255 alphanumeric characters or hyphens.   First character must be a letter.   Cannot end with a hyphen or contain two consecutive hyphens.
        public let clusterParameterGroupName: String?
        /// A list of security groups to be associated with this cluster. Default: The default cluster security group for Amazon Redshift.
        @OptionalCustomCoding<ArrayCoder<_ClusterSecurityGroupsEncoding, String>>
        public var clusterSecurityGroups: [String]?
        /// The name of a cluster subnet group to be associated with this cluster. If this parameter is not provided the resulting cluster will be deployed outside virtual private cloud (VPC).
        public let clusterSubnetGroupName: String?
        /// The type of the cluster. When cluster type is specified as    single-node, the NumberOfNodes parameter is not required.    multi-node, the NumberOfNodes parameter is required.   Valid Values: multi-node | single-node  Default: multi-node
        public let clusterType: String?
        /// The version of the Amazon Redshift engine software that you want to deploy on the cluster. The version selected runs on all the nodes in the cluster. Constraints: Only version 1.0 is currently available. Example: 1.0
        public let clusterVersion: String?
        /// The name of the first database to be created when the cluster is created. To create additional databases after the cluster is created, connect to the cluster with a SQL client and use SQL commands to create a database. For more information, go to Create a Database in the Amazon Redshift Database Developer Guide.  Default: dev  Constraints:   Must contain 1 to 64 alphanumeric characters.   Must contain only lowercase letters.   Cannot be a word that is reserved by the service. A list of reserved words can be found in Reserved Words in the Amazon Redshift Database Developer Guide.
        public let dbName: String?
        /// The Amazon Resource Name (ARN) for the IAM role that was set as default for the cluster when the cluster was created.
        public let defaultIamRoleArn: String?
        /// The Elastic IP (EIP) address for the cluster. Constraints: The cluster must be provisioned in EC2-VPC and publicly-accessible through an Internet gateway. Don't specify the Elastic IP address for a publicly accessible  cluster with availability zone relocation turned on. For more information about provisioning clusters in EC2-VPC, go to Supported Platforms to Launch Your Cluster in the Amazon Redshift Cluster Management Guide.
        public let elasticIp: String?
        /// If true, the data in the cluster is encrypted at rest.  If you set the value on this parameter to false, the request will fail. Default: true
        public let encrypted: Bool?
        /// An option that specifies whether to create the cluster with enhanced VPC routing enabled. To create a cluster that uses enhanced VPC routing, the cluster must be in a VPC. For more information, see Enhanced VPC Routing in the Amazon Redshift Cluster Management Guide. If this option is true, enhanced VPC routing is enabled.  Default: false
        public let enhancedVpcRouting: Bool?
        /// Specifies the name of the HSM client certificate the Amazon Redshift cluster uses to retrieve the data encryption keys stored in an HSM.
        public let hsmClientCertificateIdentifier: String?
        /// Specifies the name of the HSM configuration that contains the information the Amazon Redshift cluster can use to retrieve and store keys in an HSM.
        public let hsmConfigurationIdentifier: String?
        /// A list of Identity and Access Management (IAM) roles that can be used by the cluster to access other Amazon Web Services services. You must supply the IAM roles in their Amazon Resource Name (ARN) format.  The maximum number of IAM roles that you can associate is subject to a quota. For more information, go to Quotas and limits in the Amazon Redshift Cluster Management Guide.
        @OptionalCustomCoding<ArrayCoder<_IamRolesEncoding, String>>
        public var iamRoles: [String]?
        /// The IP address types that the cluster supports. Possible values are ipv4 and dualstack.
        public let ipAddressType: String?
        /// The Key Management Service (KMS) key ID of the encryption key that you want to use to encrypt data in the cluster.
        public let kmsKeyId: String?
        /// A flag that specifies whether to load sample data once the cluster is created.
        public let loadSampleData: String?
        /// An optional parameter for the name of the maintenance track for the cluster. If you don't provide a maintenance track name, the cluster is assigned to the current track.
        public let maintenanceTrackName: String?
        /// If true, Amazon Redshift uses Secrets Manager to manage this cluster's admin credentials.  You can't use MasterUserPassword if ManageMasterPassword is true.  If ManageMasterPassword is false or not set, Amazon Redshift uses  MasterUserPassword for the admin user account's password.
        public let manageMasterPassword: Bool?
        /// The default number of days to retain a manual snapshot. If the value is -1, the snapshot is retained indefinitely. This setting doesn't change the retention period of existing snapshots. The value must be either -1 or an integer between 1 and 3,653.
        public let manualSnapshotRetentionPeriod: Int?
        /// The ID of the Key Management Service (KMS) key used to encrypt and store the cluster's admin credentials secret.  You can only use this parameter if ManageMasterPassword is true.
        public let masterPasswordSecretKmsKeyId: String?
        /// The user name associated with the admin user account for the cluster that is being created. Constraints:   Must be 1 - 128 alphanumeric characters or hyphens. The user name can't be PUBLIC.   Must contain only lowercase letters, numbers, underscore, plus sign, period (dot), at symbol (@), or hyphen.   The first character must be a letter.   Must not contain a colon (:) or a slash (/).   Cannot be a reserved word. A list of reserved words can be found in Reserved Words in the Amazon Redshift Database Developer Guide.
        public let masterUsername: String?
        /// The password associated with the admin user account for the cluster that is being created. You can't use MasterUserPassword if ManageMasterPassword is true. Constraints:   Must be between 8 and 64 characters in length.   Must contain at least one uppercase letter.   Must contain at least one lowercase letter.   Must contain one number.   Can be any printable ASCII character (ASCII code 33-126) except ' (single quote), " (double quote), \, /, or @.
        public let masterUserPassword: String?
        /// If true, Amazon Redshift will deploy the cluster in two Availability Zones (AZ).
        public let multiAZ: Bool?
        /// The node type to be provisioned for the cluster. For information about node types, go to  Working with Clusters in the Amazon Redshift Cluster Management Guide.  Valid Values:  dc2.large | dc2.8xlarge |  ra3.large |  ra3.xlplus |  ra3.4xlarge | ra3.16xlarge
        public let nodeType: String?
        /// The number of compute nodes in the cluster. This parameter is required when the ClusterType parameter is specified as multi-node.  For information about determining how many nodes you need, go to  Working with Clusters in the Amazon Redshift Cluster Management Guide.  If you don't specify this parameter, you get a single-node cluster. When requesting a multi-node cluster, you must specify the number of nodes that you want in the cluster. Default: 1  Constraints: Value must be at least 1 and no more than 100.
        public let numberOfNodes: Int?
        /// The port number on which the cluster accepts incoming connections. The cluster is accessible only via the JDBC and ODBC connection strings. Part of the connection string requires the port on which the cluster will listen for incoming connections. Default: 5439  Valid Values:    For clusters with ra3 nodes - Select a port within the ranges 5431-5455 or 8191-8215. (If you have an existing cluster  with ra3 nodes, it isn't required that you change the port to these ranges.)   For clusters with dc2 nodes - Select a port within the range 1150-65535.
        public let port: Int?
        /// The weekly time range (in UTC) during which automated cluster maintenance can occur. Format: ddd:hh24:mi-ddd:hh24:mi  Default: A 30-minute window selected at random from an 8-hour block of time per region, occurring on a random day of the week. For more information about the time blocks for each region, see Maintenance Windows in Amazon Redshift Cluster Management Guide. Valid Days: Mon | Tue | Wed | Thu | Fri | Sat | Sun Constraints: Minimum 30-minute window.
        public let preferredMaintenanceWindow: String?
        /// If true, the cluster can be accessed from a public network.  Default: false
        public let publiclyAccessible: Bool?
        /// The Amazon resource name (ARN) of the Amazon Redshift IAM Identity Center application.
        public let redshiftIdcApplicationArn: String?
        /// A unique identifier for the snapshot schedule.
        public let snapshotScheduleIdentifier: String?
        /// A list of tag instances.
        @OptionalCustomCoding<ArrayCoder<_TagsEncoding, Tag>>
        public var tags: [Tag]?
        /// A list of Virtual Private Cloud (VPC) security groups to be associated with the cluster. Default: The default VPC security group is associated with the cluster.
        @OptionalCustomCoding<ArrayCoder<_VpcSecurityGroupIdsEncoding, String>>
        public var vpcSecurityGroupIds: [String]?

        @inlinable
        public init(additionalInfo: String? = nil, allowVersionUpgrade: Bool? = nil, aquaConfigurationStatus: AquaConfigurationStatus? = nil, automatedSnapshotRetentionPeriod: Int? = nil, availabilityZone: String? = nil, availabilityZoneRelocation: Bool? = nil, clusterIdentifier: String? = nil, clusterParameterGroupName: String? = nil, clusterSecurityGroups: [String]? = nil, clusterSubnetGroupName: String? = nil, clusterType: String? = nil, clusterVersion: String? = nil, dbName: String? = nil, defaultIamRoleArn: String? = nil, elasticIp: String? = nil, encrypted: Bool? = nil, enhancedVpcRouting: Bool? = nil, hsmClientCertificateIdentifier: String? = nil, hsmConfigurationIdentifier: String? = nil, iamRoles: [String]? = nil, ipAddressType: String? = nil, kmsKeyId: String? = nil, loadSampleData: String? = nil, maintenanceTrackName: String? = nil, manageMasterPassword: Bool? = nil, manualSnapshotRetentionPeriod: Int? = nil, masterPasswordSecretKmsKeyId: String? = nil, masterUsername: String? = nil, masterUserPassword: String? = nil, multiAZ: Bool? = nil, nodeType: String? = nil, numberOfNodes: Int? = nil, port: Int? = nil, preferredMaintenanceWindow: String? = nil, publiclyAccessible: Bool? = nil, redshiftIdcApplicationArn: String? = nil, snapshotScheduleIdentifier: String? = nil, tags: [Tag]? = nil, vpcSecurityGroupIds: [String]? = nil) {
            self.additionalInfo = additionalInfo
            self.allowVersionUpgrade = allowVersionUpgrade
            self.aquaConfigurationStatus = aquaConfigurationStatus
            self.automatedSnapshotRetentionPeriod = automatedSnapshotRetentionPeriod
            self.availabilityZone = availabilityZone
            self.availabilityZoneRelocation = availabilityZoneRelocation
            self.clusterIdentifier = clusterIdentifier
            self.clusterParameterGroupName = clusterParameterGroupName
            self.clusterSecurityGroups = clusterSecurityGroups
            self.clusterSubnetGroupName = clusterSubnetGroupName
            self.clusterType = clusterType
            self.clusterVersion = clusterVersion
            self.dbName = dbName
            self.defaultIamRoleArn = defaultIamRoleArn
            self.elasticIp = elasticIp
            self.encrypted = encrypted
            self.enhancedVpcRouting = enhancedVpcRouting
            self.hsmClientCertificateIdentifier = hsmClientCertificateIdentifier
            self.hsmConfigurationIdentifier = hsmConfigurationIdentifier
            self.iamRoles = iamRoles
            self.ipAddressType = ipAddressType
            self.kmsKeyId = kmsKeyId
            self.loadSampleData = loadSampleData
            self.maintenanceTrackName = maintenanceTrackName
            self.manageMasterPassword = manageMasterPassword
            self.manualSnapshotRetentionPeriod = manualSnapshotRetentionPeriod
            self.masterPasswordSecretKmsKeyId = masterPasswordSecretKmsKeyId
            self.masterUsername = masterUsername
            self.masterUserPassword = masterUserPassword
            self.multiAZ = multiAZ
            self.nodeType = nodeType
            self.numberOfNodes = numberOfNodes
            self.port = port
            self.preferredMaintenanceWindow = preferredMaintenanceWindow
            self.publiclyAccessible = publiclyAccessible
            self.redshiftIdcApplicationArn = redshiftIdcApplicationArn
            self.snapshotScheduleIdentifier = snapshotScheduleIdentifier
            self.tags = tags
            self.vpcSecurityGroupIds = vpcSecurityGroupIds
        }

        public func validate(name: String) throws {
            try self.validate(self.additionalInfo, name: "additionalInfo", parent: name, max: 2147483647)
            try self.validate(self.availabilityZone, name: "availabilityZone", parent: name, max: 2147483647)
            try self.validate(self.clusterIdentifier, name: "clusterIdentifier", parent: name, max: 2147483647)
            try self.validate(self.clusterParameterGroupName, name: "clusterParameterGroupName", parent: name, max: 2147483647)
            try self.clusterSecurityGroups?.forEach {
                try validate($0, name: "clusterSecurityGroups[]", parent: name, max: 2147483647)
            }
            try self.validate(self.clusterSubnetGroupName, name: "clusterSubnetGroupName", parent: name, max: 2147483647)
            try self.validate(self.clusterType, name: "clusterType", parent: name, max: 2147483647)
            try self.validate(self.clusterVersion, name: "clusterVersion", parent: name, max: 2147483647)
            try self.validate(self.dbName, name: "dbName", parent: name, max: 2147483647)
            try self.validate(self.defaultIamRoleArn, name: "defaultIamRoleArn", parent: name, max: 2147483647)
            try self.validate(self.elasticIp, name: "elasticIp", parent: name, max: 2147483647)
            try self.validate(self.hsmClientCertificateIdentifier, name: "hsmClientCertificateIdentifier", parent: name, max: 2147483647)
            try self.validate(self.hsmConfigurationIdentifier, name: "hsmConfigurationIdentifier", parent: name, max: 2147483647)
            try self.iamRoles?.forEach {
                try validate($0, name: "iamRoles[]", parent: name, max: 2147483647)
            }
            try self.validate(self.ipAddressType, name: "ipAddressType", parent: name, max: 2147483647)
            try self.validate(self.kmsKeyId, name: "kmsKeyId", parent: name, max: 2147483647)
            try self.validate(self.loadSampleData, name: "loadSampleData", parent: name, max: 2147483647)
            try self.validate(self.maintenanceTrackName, name: "maintenanceTrackName", parent: name, max: 2147483647)
            try self.validate(self.masterPasswordSecretKmsKeyId, name: "masterPasswordSecretKmsKeyId", parent: name, max: 2147483647)
            try self.validate(self.masterUsername, name: "masterUsername", parent: name, max: 2147483647)
            try self.validate(self.nodeType, name: "nodeType", parent: name, max: 2147483647)
            try self.validate(self.preferredMaintenanceWindow, name: "preferredMaintenanceWindow", parent: name, max: 2147483647)
            try self.validate(self.redshiftIdcApplicationArn, name: "redshiftIdcApplicationArn", parent: name, max: 2147483647)
            try self.validate(self.snapshotScheduleIdentifier, name: "snapshotScheduleIdentifier", parent: name, max: 2147483647)
            try self.tags?.forEach {
                try $0.validate(name: "\(name).tags[]")
            }
            try self.vpcSecurityGroupIds?.forEach {
                try validate($0, name: "vpcSecurityGroupIds[]", parent: name, max: 2147483647)
            }
        }

        private enum CodingKeys: String, CodingKey {
            case additionalInfo = "AdditionalInfo"
            case allowVersionUpgrade = "AllowVersionUpgrade"
            case aquaConfigurationStatus = "AquaConfigurationStatus"
            case automatedSnapshotRetentionPeriod = "AutomatedSnapshotRetentionPeriod"
            case availabilityZone = "AvailabilityZone"
            case availabilityZoneRelocation = "AvailabilityZoneRelocation"
            case clusterIdentifier = "ClusterIdentifier"
            case clusterParameterGroupName = "ClusterParameterGroupName"
            case clusterSecurityGroups = "ClusterSecurityGroups"
            case clusterSubnetGroupName = "ClusterSubnetGroupName"
            case clusterType = "ClusterType"
            case clusterVersion = "ClusterVersion"
            case dbName = "DBName"
            case defaultIamRoleArn = "DefaultIamRoleArn"
            case elasticIp = "ElasticIp"
            case encrypted = "Encrypted"
            case enhancedVpcRouting = "EnhancedVpcRouting"
            case hsmClientCertificateIdentifier = "HsmClientCertificateIdentifier"
            case hsmConfigurationIdentifier = "HsmConfigurationIdentifier"
            case iamRoles = "IamRoles"
            case ipAddressType = "IpAddressType"
            case kmsKeyId = "KmsKeyId"
            case loadSampleData = "LoadSampleData"
            case maintenanceTrackName = "MaintenanceTrackName"
            case manageMasterPassword = "ManageMasterPassword"
            case manualSnapshotRetentionPeriod = "ManualSnapshotRetentionPeriod"
            case masterPasswordSecretKmsKeyId = "MasterPasswordSecretKmsKeyId"
            case masterUsername = "MasterUsername"
            case masterUserPassword = "MasterUserPassword"
            case multiAZ = "MultiAZ"
            case nodeType = "NodeType"
            case numberOfNodes = "NumberOfNodes"
            case port = "Port"
            case preferredMaintenanceWindow = "PreferredMaintenanceWindow"
            case publiclyAccessible = "PubliclyAccessible"
            case redshiftIdcApplicationArn = "RedshiftIdcApplicationArn"
            case snapshotScheduleIdentifier = "SnapshotScheduleIdentifier"
            case tags = "Tags"
            case vpcSecurityGroupIds = "VpcSecurityGroupIds"
        }
    }

    public struct CreateClusterParameterGroupMessage: AWSEncodableShape {
        public struct _TagsEncoding: ArrayCoderProperties { public static let member = "Tag" }

        /// A description of the parameter group.
        public let description: String?
        /// The Amazon Redshift engine version to which the cluster parameter group applies. The cluster engine version determines the set of parameters. To get a list of valid parameter group family names, you can call DescribeClusterParameterGroups. By default, Amazon Redshift returns a list of all the parameter groups that are owned by your Amazon Web Services account, including the default parameter groups for each Amazon Redshift engine version. The parameter group family names associated with the default parameter groups provide you the valid values. For example, a valid family name is "redshift-1.0".
        public let parameterGroupFamily: String?
        /// The name of the cluster parameter group. Constraints:   Must be 1 to 255 alphanumeric characters or hyphens   First character must be a letter.   Cannot end with a hyphen or contain two consecutive hyphens.   Must be unique withing your Amazon Web Services account.    This value is stored as a lower-case string.
        public let parameterGroupName: String?
        /// A list of tag instances.
        @OptionalCustomCoding<ArrayCoder<_TagsEncoding, Tag>>
        public var tags: [Tag]?

        @inlinable
        public init(description: String? = nil, parameterGroupFamily: String? = nil, parameterGroupName: String? = nil, tags: [Tag]? = nil) {
            self.description = description
            self.parameterGroupFamily = parameterGroupFamily
            self.parameterGroupName = parameterGroupName
            self.tags = tags
        }

        public func validate(name: String) throws {
            try self.validate(self.description, name: "description", parent: name, max: 2147483647)
            try self.validate(self.parameterGroupFamily, name: "parameterGroupFamily", parent: name, max: 2147483647)
            try self.validate(self.parameterGroupName, name: "parameterGroupName", parent: name, max: 2147483647)
            try self.tags?.forEach {
                try $0.validate(name: "\(name).tags[]")
            }
        }

        private enum CodingKeys: String, CodingKey {
            case description = "Description"
            case parameterGroupFamily = "ParameterGroupFamily"
            case parameterGroupName = "ParameterGroupName"
            case tags = "Tags"
        }
    }

    public struct CreateClusterParameterGroupResult: AWSDecodableShape {
        public let clusterParameterGroup: ClusterParameterGroup?

        @inlinable
        public init(clusterParameterGroup: ClusterParameterGroup? = nil) {
            self.clusterParameterGroup = clusterParameterGroup
        }

        private enum CodingKeys: String, CodingKey {
            case clusterParameterGroup = "ClusterParameterGroup"
        }
    }

    public struct CreateClusterResult: AWSDecodableShape {
        public let cluster: Cluster?

        @inlinable
        public init(cluster: Cluster? = nil) {
            self.cluster = cluster
        }

        private enum CodingKeys: String, CodingKey {
            case cluster = "Cluster"
        }
    }

    public struct CreateClusterSecurityGroupMessage: AWSEncodableShape {
        public struct _TagsEncoding: ArrayCoderProperties { public static let member = "Tag" }

        /// The name for the security group. Amazon Redshift stores the value as a lowercase string. Constraints:   Must contain no more than 255 alphanumeric characters or hyphens.   Must not be "Default".   Must be unique for all security groups that are created by your Amazon Web Services account.   Example: examplesecuritygroup
        public let clusterSecurityGroupName: String?
        /// A description for the security group.
        public let description: String?
        /// A list of tag instances.
        @OptionalCustomCoding<ArrayCoder<_TagsEncoding, Tag>>
        public var tags: [Tag]?

        @inlinable
        public init(clusterSecurityGroupName: String? = nil, description: String? = nil, tags: [Tag]? = nil) {
            self.clusterSecurityGroupName = clusterSecurityGroupName
            self.description = description
            self.tags = tags
        }

        public func validate(name: String) throws {
            try self.validate(self.clusterSecurityGroupName, name: "clusterSecurityGroupName", parent: name, max: 2147483647)
            try self.validate(self.description, name: "description", parent: name, max: 2147483647)
            try self.tags?.forEach {
                try $0.validate(name: "\(name).tags[]")
            }
        }

        private enum CodingKeys: String, CodingKey {
            case clusterSecurityGroupName = "ClusterSecurityGroupName"
            case description = "Description"
            case tags = "Tags"
        }
    }

    public struct CreateClusterSecurityGroupResult: AWSDecodableShape {
        public let clusterSecurityGroup: ClusterSecurityGroup?

        @inlinable
        public init(clusterSecurityGroup: ClusterSecurityGroup? = nil) {
            self.clusterSecurityGroup = clusterSecurityGroup
        }

        private enum CodingKeys: String, CodingKey {
            case clusterSecurityGroup = "ClusterSecurityGroup"
        }
    }

    public struct CreateClusterSnapshotMessage: AWSEncodableShape {
        public struct _TagsEncoding: ArrayCoderProperties { public static let member = "Tag" }

        /// The cluster identifier for which you want a snapshot.
        public let clusterIdentifier: String?
        /// The number of days that a manual snapshot is retained. If the value is -1, the manual snapshot is retained indefinitely.  The value must be either -1 or an integer between 1 and 3,653. The default value is -1.
        public let manualSnapshotRetentionPeriod: Int?
        /// A unique identifier for the snapshot that you are requesting. This identifier must be unique for all snapshots within the Amazon Web Services account. Constraints:   Cannot be null, empty, or blank   Must contain from 1 to 255 alphanumeric characters or hyphens   First character must be a letter   Cannot end with a hyphen or contain two consecutive hyphens   Example: my-snapshot-id
        public let snapshotIdentifier: String?
        /// A list of tag instances.
        @OptionalCustomCoding<ArrayCoder<_TagsEncoding, Tag>>
        public var tags: [Tag]?

        @inlinable
        public init(clusterIdentifier: String? = nil, manualSnapshotRetentionPeriod: Int? = nil, snapshotIdentifier: String? = nil, tags: [Tag]? = nil) {
            self.clusterIdentifier = clusterIdentifier
            self.manualSnapshotRetentionPeriod = manualSnapshotRetentionPeriod
            self.snapshotIdentifier = snapshotIdentifier
            self.tags = tags
        }

        public func validate(name: String) throws {
            try self.validate(self.clusterIdentifier, name: "clusterIdentifier", parent: name, max: 2147483647)
            try self.validate(self.snapshotIdentifier, name: "snapshotIdentifier", parent: name, max: 2147483647)
            try self.tags?.forEach {
                try $0.validate(name: "\(name).tags[]")
            }
        }

        private enum CodingKeys: String, CodingKey {
            case clusterIdentifier = "ClusterIdentifier"
            case manualSnapshotRetentionPeriod = "ManualSnapshotRetentionPeriod"
            case snapshotIdentifier = "SnapshotIdentifier"
            case tags = "Tags"
        }
    }

    public struct CreateClusterSnapshotResult: AWSDecodableShape {
        public let snapshot: Snapshot?

        @inlinable
        public init(snapshot: Snapshot? = nil) {
            self.snapshot = snapshot
        }

        private enum CodingKeys: String, CodingKey {
            case snapshot = "Snapshot"
        }
    }

    public struct CreateClusterSubnetGroupMessage: AWSEncodableShape {
        public struct _SubnetIdsEncoding: ArrayCoderProperties { public static let member = "SubnetIdentifier" }
        public struct _TagsEncoding: ArrayCoderProperties { public static let member = "Tag" }

        /// The name for the subnet group. Amazon Redshift stores the value as a lowercase string. Constraints:   Must contain no more than 255 alphanumeric characters or hyphens.   Must not be "Default".   Must be unique for all subnet groups that are created by your Amazon Web Services account.   Example: examplesubnetgroup
        public let clusterSubnetGroupName: String?
        /// A description for the subnet group.
        public let description: String?
        /// An array of VPC subnet IDs. A maximum of 20 subnets can be modified in a single request.
        @OptionalCustomCoding<ArrayCoder<_SubnetIdsEncoding, String>>
        public var subnetIds: [String]?
        /// A list of tag instances.
        @OptionalCustomCoding<ArrayCoder<_TagsEncoding, Tag>>
        public var tags: [Tag]?

        @inlinable
        public init(clusterSubnetGroupName: String? = nil, description: String? = nil, subnetIds: [String]? = nil, tags: [Tag]? = nil) {
            self.clusterSubnetGroupName = clusterSubnetGroupName
            self.description = description
            self.subnetIds = subnetIds
            self.tags = tags
        }

        public func validate(name: String) throws {
            try self.validate(self.clusterSubnetGroupName, name: "clusterSubnetGroupName", parent: name, max: 2147483647)
            try self.validate(self.description, name: "description", parent: name, max: 2147483647)
            try self.subnetIds?.forEach {
                try validate($0, name: "subnetIds[]", parent: name, max: 2147483647)
            }
            try self.tags?.forEach {
                try $0.validate(name: "\(name).tags[]")
            }
        }

        private enum CodingKeys: String, CodingKey {
            case clusterSubnetGroupName = "ClusterSubnetGroupName"
            case description = "Description"
            case subnetIds = "SubnetIds"
            case tags = "Tags"
        }
    }

    public struct CreateClusterSubnetGroupResult: AWSDecodableShape {
        public let clusterSubnetGroup: ClusterSubnetGroup?

        @inlinable
        public init(clusterSubnetGroup: ClusterSubnetGroup? = nil) {
            self.clusterSubnetGroup = clusterSubnetGroup
        }

        private enum CodingKeys: String, CodingKey {
            case clusterSubnetGroup = "ClusterSubnetGroup"
        }
    }

    public struct CreateCustomDomainAssociationMessage: AWSEncodableShape {
        /// The cluster identifier that the custom domain is associated with.
        public let clusterIdentifier: String?
        /// The certificate Amazon Resource Name (ARN) for the custom domain name association.
        public let customDomainCertificateArn: String?
        /// The custom domain name for a custom domain association.
        public let customDomainName: String?

        @inlinable
        public init(clusterIdentifier: String? = nil, customDomainCertificateArn: String? = nil, customDomainName: String? = nil) {
            self.clusterIdentifier = clusterIdentifier
            self.customDomainCertificateArn = customDomainCertificateArn
            self.customDomainName = customDomainName
        }

        public func validate(name: String) throws {
            try self.validate(self.clusterIdentifier, name: "clusterIdentifier", parent: name, max: 2147483647)
            try self.validate(self.customDomainCertificateArn, name: "customDomainCertificateArn", parent: name, max: 2048)
            try self.validate(self.customDomainCertificateArn, name: "customDomainCertificateArn", parent: name, min: 20)
            try self.validate(self.customDomainCertificateArn, name: "customDomainCertificateArn", parent: name, pattern: "^arn:[\\w+=/,.@-]+:acm:[\\w+=/,.@-]*:[0-9]+:[\\w+=,.@-]+(/[\\w+=,.@-]+)*$")
            try self.validate(self.customDomainName, name: "customDomainName", parent: name, max: 253)
            try self.validate(self.customDomainName, name: "customDomainName", parent: name, min: 1)
            try self.validate(self.customDomainName, name: "customDomainName", parent: name, pattern: "^(((?!-)[A-Za-z0-9-]{0,62}[A-Za-z0-9])\\.)+((?!-)[A-Za-z0-9-]{1,62}[A-Za-z0-9])$")
        }

        private enum CodingKeys: String, CodingKey {
            case clusterIdentifier = "ClusterIdentifier"
            case customDomainCertificateArn = "CustomDomainCertificateArn"
            case customDomainName = "CustomDomainName"
        }
    }

    public struct CreateCustomDomainAssociationResult: AWSDecodableShape {
        /// The identifier of the cluster that the custom domain is associated with.
        public let clusterIdentifier: String?
        /// The expiration time for the certificate for the custom domain.
        public let customDomainCertExpiryTime: String?
        /// The Amazon Resource Name (ARN) for the certificate associated with the custom domain name.
        public let customDomainCertificateArn: String?
        /// The custom domain name for the association result.
        public let customDomainName: String?

        @inlinable
        public init(clusterIdentifier: String? = nil, customDomainCertExpiryTime: String? = nil, customDomainCertificateArn: String? = nil, customDomainName: String? = nil) {
            self.clusterIdentifier = clusterIdentifier
            self.customDomainCertExpiryTime = customDomainCertExpiryTime
            self.customDomainCertificateArn = customDomainCertificateArn
            self.customDomainName = customDomainName
        }

        private enum CodingKeys: String, CodingKey {
            case clusterIdentifier = "ClusterIdentifier"
            case customDomainCertExpiryTime = "CustomDomainCertExpiryTime"
            case customDomainCertificateArn = "CustomDomainCertificateArn"
            case customDomainName = "CustomDomainName"
        }
    }

    public struct CreateEndpointAccessMessage: AWSEncodableShape {
        public struct _VpcSecurityGroupIdsEncoding: ArrayCoderProperties { public static let member = "VpcSecurityGroupId" }

        /// The cluster identifier of the cluster to access.
        public let clusterIdentifier: String?
        /// The Redshift-managed VPC endpoint name. An endpoint name must contain 1-30 characters. Valid characters are A-Z, a-z, 0-9, and hyphen(-). The first character must be a letter. The name can't contain two consecutive hyphens or end with a hyphen.
        public let endpointName: String?
        /// The Amazon Web Services account ID of the owner of the cluster. This is only required if the cluster is in another Amazon Web Services account.
        public let resourceOwner: String?
        /// The subnet group from which Amazon Redshift chooses the subnet to deploy the endpoint.
        public let subnetGroupName: String?
        /// The security group that defines the ports, protocols, and sources for inbound traffic that you are authorizing into your endpoint.
        @OptionalCustomCoding<ArrayCoder<_VpcSecurityGroupIdsEncoding, String>>
        public var vpcSecurityGroupIds: [String]?

        @inlinable
        public init(clusterIdentifier: String? = nil, endpointName: String? = nil, resourceOwner: String? = nil, subnetGroupName: String? = nil, vpcSecurityGroupIds: [String]? = nil) {
            self.clusterIdentifier = clusterIdentifier
            self.endpointName = endpointName
            self.resourceOwner = resourceOwner
            self.subnetGroupName = subnetGroupName
            self.vpcSecurityGroupIds = vpcSecurityGroupIds
        }

        public func validate(name: String) throws {
            try self.validate(self.clusterIdentifier, name: "clusterIdentifier", parent: name, max: 2147483647)
            try self.validate(self.endpointName, name: "endpointName", parent: name, max: 2147483647)
            try self.validate(self.resourceOwner, name: "resourceOwner", parent: name, max: 2147483647)
            try self.validate(self.subnetGroupName, name: "subnetGroupName", parent: name, max: 2147483647)
            try self.vpcSecurityGroupIds?.forEach {
                try validate($0, name: "vpcSecurityGroupIds[]", parent: name, max: 2147483647)
            }
        }

        private enum CodingKeys: String, CodingKey {
            case clusterIdentifier = "ClusterIdentifier"
            case endpointName = "EndpointName"
            case resourceOwner = "ResourceOwner"
            case subnetGroupName = "SubnetGroupName"
            case vpcSecurityGroupIds = "VpcSecurityGroupIds"
        }
    }

    public struct CreateEventSubscriptionMessage: AWSEncodableShape {
        public struct _EventCategoriesEncoding: ArrayCoderProperties { public static let member = "EventCategory" }
        public struct _SourceIdsEncoding: ArrayCoderProperties { public static let member = "SourceId" }
        public struct _TagsEncoding: ArrayCoderProperties { public static let member = "Tag" }

        /// A boolean value; set to true to activate the subscription, and set to false to create the subscription but not activate it.
        public let enabled: Bool?
        /// Specifies the Amazon Redshift event categories to be published by the event notification subscription. Values: configuration, management, monitoring, security, pending
        @OptionalCustomCoding<ArrayCoder<_EventCategoriesEncoding, String>>
        public var eventCategories: [String]?
        /// Specifies the Amazon Redshift event severity to be published by the event notification subscription. Values: ERROR, INFO
        public let severity: String?
        /// The Amazon Resource Name (ARN) of the Amazon SNS topic used to transmit the event notifications. The ARN is created by Amazon SNS when you create a topic and subscribe to it.
        public let snsTopicArn: String?
        /// A list of one or more identifiers of Amazon Redshift source objects. All of the objects must be of the same type as was specified in the source type parameter. The event subscription will return only events generated by the specified objects. If not specified, then events are returned for all objects within the source type specified. Example: my-cluster-1, my-cluster-2 Example: my-snapshot-20131010
        @OptionalCustomCoding<ArrayCoder<_SourceIdsEncoding, String>>
        public var sourceIds: [String]?
        /// The type of source that will be generating the events. For example, if you want to be notified of events generated by a cluster, you would set this parameter to cluster. If this value is not specified, events are returned for all Amazon Redshift objects in your Amazon Web Services account. You must specify a source type in order to specify source IDs. Valid values: cluster, cluster-parameter-group, cluster-security-group, cluster-snapshot, and scheduled-action.
        public let sourceType: String?
        /// The name of the event subscription to be created. Constraints:   Cannot be null, empty, or blank.   Must contain from 1 to 255 alphanumeric characters or hyphens.   First character must be a letter.   Cannot end with a hyphen or contain two consecutive hyphens.
        public let subscriptionName: String?
        /// A list of tag instances.
        @OptionalCustomCoding<ArrayCoder<_TagsEncoding, Tag>>
        public var tags: [Tag]?

        @inlinable
        public init(enabled: Bool? = nil, eventCategories: [String]? = nil, severity: String? = nil, snsTopicArn: String? = nil, sourceIds: [String]? = nil, sourceType: String? = nil, subscriptionName: String? = nil, tags: [Tag]? = nil) {
            self.enabled = enabled
            self.eventCategories = eventCategories
            self.severity = severity
            self.snsTopicArn = snsTopicArn
            self.sourceIds = sourceIds
            self.sourceType = sourceType
            self.subscriptionName = subscriptionName
            self.tags = tags
        }

        public func validate(name: String) throws {
            try self.eventCategories?.forEach {
                try validate($0, name: "eventCategories[]", parent: name, max: 2147483647)
            }
            try self.validate(self.severity, name: "severity", parent: name, max: 2147483647)
            try self.validate(self.snsTopicArn, name: "snsTopicArn", parent: name, max: 2147483647)
            try self.sourceIds?.forEach {
                try validate($0, name: "sourceIds[]", parent: name, max: 2147483647)
            }
            try self.validate(self.sourceType, name: "sourceType", parent: name, max: 2147483647)
            try self.validate(self.subscriptionName, name: "subscriptionName", parent: name, max: 2147483647)
            try self.tags?.forEach {
                try $0.validate(name: "\(name).tags[]")
            }
        }

        private enum CodingKeys: String, CodingKey {
            case enabled = "Enabled"
            case eventCategories = "EventCategories"
            case severity = "Severity"
            case snsTopicArn = "SnsTopicArn"
            case sourceIds = "SourceIds"
            case sourceType = "SourceType"
            case subscriptionName = "SubscriptionName"
            case tags = "Tags"
        }
    }

    public struct CreateEventSubscriptionResult: AWSDecodableShape {
        public let eventSubscription: EventSubscription?

        @inlinable
        public init(eventSubscription: EventSubscription? = nil) {
            self.eventSubscription = eventSubscription
        }

        private enum CodingKeys: String, CodingKey {
            case eventSubscription = "EventSubscription"
        }
    }

    public struct CreateHsmClientCertificateMessage: AWSEncodableShape {
        public struct _TagsEncoding: ArrayCoderProperties { public static let member = "Tag" }

        /// The identifier to be assigned to the new HSM client certificate that the cluster will use to connect to the HSM to use the database encryption keys.
        public let hsmClientCertificateIdentifier: String?
        /// A list of tag instances.
        @OptionalCustomCoding<ArrayCoder<_TagsEncoding, Tag>>
        public var tags: [Tag]?

        @inlinable
        public init(hsmClientCertificateIdentifier: String? = nil, tags: [Tag]? = nil) {
            self.hsmClientCertificateIdentifier = hsmClientCertificateIdentifier
            self.tags = tags
        }

        public func validate(name: String) throws {
            try self.validate(self.hsmClientCertificateIdentifier, name: "hsmClientCertificateIdentifier", parent: name, max: 2147483647)
            try self.tags?.forEach {
                try $0.validate(name: "\(name).tags[]")
            }
        }

        private enum CodingKeys: String, CodingKey {
            case hsmClientCertificateIdentifier = "HsmClientCertificateIdentifier"
            case tags = "Tags"
        }
    }

    public struct CreateHsmClientCertificateResult: AWSDecodableShape {
        public let hsmClientCertificate: HsmClientCertificate?

        @inlinable
        public init(hsmClientCertificate: HsmClientCertificate? = nil) {
            self.hsmClientCertificate = hsmClientCertificate
        }

        private enum CodingKeys: String, CodingKey {
            case hsmClientCertificate = "HsmClientCertificate"
        }
    }

    public struct CreateHsmConfigurationMessage: AWSEncodableShape {
        public struct _TagsEncoding: ArrayCoderProperties { public static let member = "Tag" }

        /// A text description of the HSM configuration to be created.
        public let description: String?
        /// The identifier to be assigned to the new Amazon Redshift HSM configuration.
        public let hsmConfigurationIdentifier: String?
        /// The IP address that the Amazon Redshift cluster must use to access the HSM.
        public let hsmIpAddress: String?
        /// The name of the partition in the HSM where the Amazon Redshift clusters will store their database encryption keys.
        public let hsmPartitionName: String?
        /// The password required to access the HSM partition.
        public let hsmPartitionPassword: String?
        /// The HSMs public certificate file. When using Cloud HSM, the file name is server.pem.
        public let hsmServerPublicCertificate: String?
        /// A list of tag instances.
        @OptionalCustomCoding<ArrayCoder<_TagsEncoding, Tag>>
        public var tags: [Tag]?

        @inlinable
        public init(description: String? = nil, hsmConfigurationIdentifier: String? = nil, hsmIpAddress: String? = nil, hsmPartitionName: String? = nil, hsmPartitionPassword: String? = nil, hsmServerPublicCertificate: String? = nil, tags: [Tag]? = nil) {
            self.description = description
            self.hsmConfigurationIdentifier = hsmConfigurationIdentifier
            self.hsmIpAddress = hsmIpAddress
            self.hsmPartitionName = hsmPartitionName
            self.hsmPartitionPassword = hsmPartitionPassword
            self.hsmServerPublicCertificate = hsmServerPublicCertificate
            self.tags = tags
        }

        public func validate(name: String) throws {
            try self.validate(self.description, name: "description", parent: name, max: 2147483647)
            try self.validate(self.hsmConfigurationIdentifier, name: "hsmConfigurationIdentifier", parent: name, max: 2147483647)
            try self.validate(self.hsmIpAddress, name: "hsmIpAddress", parent: name, max: 2147483647)
            try self.validate(self.hsmPartitionName, name: "hsmPartitionName", parent: name, max: 2147483647)
            try self.validate(self.hsmPartitionPassword, name: "hsmPartitionPassword", parent: name, max: 2147483647)
            try self.validate(self.hsmServerPublicCertificate, name: "hsmServerPublicCertificate", parent: name, max: 2147483647)
            try self.tags?.forEach {
                try $0.validate(name: "\(name).tags[]")
            }
        }

        private enum CodingKeys: String, CodingKey {
            case description = "Description"
            case hsmConfigurationIdentifier = "HsmConfigurationIdentifier"
            case hsmIpAddress = "HsmIpAddress"
            case hsmPartitionName = "HsmPartitionName"
            case hsmPartitionPassword = "HsmPartitionPassword"
            case hsmServerPublicCertificate = "HsmServerPublicCertificate"
            case tags = "Tags"
        }
    }

    public struct CreateHsmConfigurationResult: AWSDecodableShape {
        public let hsmConfiguration: HsmConfiguration?

        @inlinable
        public init(hsmConfiguration: HsmConfiguration? = nil) {
            self.hsmConfiguration = hsmConfiguration
        }

        private enum CodingKeys: String, CodingKey {
            case hsmConfiguration = "HsmConfiguration"
        }
    }

    public struct CreateIntegrationMessage: AWSEncodableShape {
        public struct _TagListEncoding: ArrayCoderProperties { public static let member = "Tag" }

        /// An optional set of non-secret key–value pairs that contains additional contextual information about the data. For more information, see Encryption context in the Amazon Web Services Key Management Service Developer Guide. You can only include this parameter if you specify the KMSKeyId parameter.
        @OptionalCustomCoding<StandardDictionaryCoder<String, String>>
        public var additionalEncryptionContext: [String: String]?
        /// A description of the integration.
        public let description: String?
        /// The name of the integration.
        public let integrationName: String?
        /// An Key Management Service (KMS) key identifier for the key to use to encrypt the integration. If you don't specify an encryption key, the default Amazon Web Services owned key is used.
        public let kmsKeyId: String?
        /// The Amazon Resource Name (ARN) of the database to use as the source for replication.
        public let sourceArn: String?
        /// A list of tags.
        @OptionalCustomCoding<ArrayCoder<_TagListEncoding, Tag>>
        public var tagList: [Tag]?
        /// The Amazon Resource Name (ARN) of the Amazon Redshift data warehouse to use as the target for replication.
        public let targetArn: String?

        @inlinable
        public init(additionalEncryptionContext: [String: String]? = nil, description: String? = nil, integrationName: String? = nil, kmsKeyId: String? = nil, sourceArn: String? = nil, tagList: [Tag]? = nil, targetArn: String? = nil) {
            self.additionalEncryptionContext = additionalEncryptionContext
            self.description = description
            self.integrationName = integrationName
            self.kmsKeyId = kmsKeyId
            self.sourceArn = sourceArn
            self.tagList = tagList
            self.targetArn = targetArn
        }

        public func validate(name: String) throws {
            try self.additionalEncryptionContext?.forEach {
                try validate($0.key, name: "additionalEncryptionContext.key", parent: name, max: 2147483647)
                try validate($0.value, name: "additionalEncryptionContext[\"\($0.key)\"]", parent: name, max: 2147483647)
            }
            try self.validate(self.description, name: "description", parent: name, max: 1000)
            try self.validate(self.description, name: "description", parent: name, pattern: "^.*$")
            try self.validate(self.integrationName, name: "integrationName", parent: name, max: 63)
            try self.validate(self.integrationName, name: "integrationName", parent: name, min: 1)
            try self.validate(self.integrationName, name: "integrationName", parent: name, pattern: "^[a-zA-Z][a-zA-Z0-9]*(-[a-zA-Z0-9]+)*$")
            try self.validate(self.kmsKeyId, name: "kmsKeyId", parent: name, max: 2147483647)
            try self.validate(self.sourceArn, name: "sourceArn", parent: name, max: 255)
            try self.validate(self.sourceArn, name: "sourceArn", parent: name, min: 1)
            try self.validate(self.sourceArn, name: "sourceArn", parent: name, pattern: "^arn:aws[a-z\\-]*:(s3|dynamodb):.*:.*:[a-zA-Z0-9._\\-\\/]+$")
            try self.tagList?.forEach {
                try $0.validate(name: "\(name).tagList[]")
            }
            try self.validate(self.targetArn, name: "targetArn", parent: name, max: 2048)
            try self.validate(self.targetArn, name: "targetArn", parent: name, min: 20)
            try self.validate(self.targetArn, name: "targetArn", parent: name, pattern: "^arn:aws[a-z\\-]*:redshift(-serverless)?:[a-z0-9\\-]+:[0-9]{12}:(namespace\\/|namespace:)[a-z0-9\\-]+$")
        }

        private enum CodingKeys: String, CodingKey {
            case additionalEncryptionContext = "AdditionalEncryptionContext"
            case description = "Description"
            case integrationName = "IntegrationName"
            case kmsKeyId = "KMSKeyId"
            case sourceArn = "SourceArn"
            case tagList = "TagList"
            case targetArn = "TargetArn"
        }
    }

    public struct CreateRedshiftIdcApplicationMessage: AWSEncodableShape {
        /// The token issuer list for the Amazon Redshift IAM Identity Center application instance.
        @OptionalCustomCoding<StandardArrayCoder<AuthorizedTokenIssuer>>
        public var authorizedTokenIssuerList: [AuthorizedTokenIssuer]?
        /// The IAM role ARN for the Amazon Redshift IAM Identity Center application instance. It has the required permissions  to be assumed and invoke the IDC Identity Center API.
        public let iamRoleArn: String?
        /// The display name for the Amazon Redshift IAM Identity Center application instance. It appears in the console.
        public let idcDisplayName: String?
        /// The Amazon resource name (ARN) of the IAM Identity Center instance where Amazon Redshift creates a new managed application.
        public let idcInstanceArn: String?
        /// The namespace for the Amazon Redshift IAM Identity Center application instance. It determines which managed application  verifies the connection token.
        public let identityNamespace: String?
        /// The name of the Redshift application in IAM Identity Center.
        public let redshiftIdcApplicationName: String?
        /// A collection of service integrations for the Redshift IAM Identity Center application.
        @OptionalCustomCoding<StandardArrayCoder<ServiceIntegrationsUnion>>
        public var serviceIntegrations: [ServiceIntegrationsUnion]?

        @inlinable
        public init(authorizedTokenIssuerList: [AuthorizedTokenIssuer]? = nil, iamRoleArn: String? = nil, idcDisplayName: String? = nil, idcInstanceArn: String? = nil, identityNamespace: String? = nil, redshiftIdcApplicationName: String? = nil, serviceIntegrations: [ServiceIntegrationsUnion]? = nil) {
            self.authorizedTokenIssuerList = authorizedTokenIssuerList
            self.iamRoleArn = iamRoleArn
            self.idcDisplayName = idcDisplayName
            self.idcInstanceArn = idcInstanceArn
            self.identityNamespace = identityNamespace
            self.redshiftIdcApplicationName = redshiftIdcApplicationName
            self.serviceIntegrations = serviceIntegrations
        }

        public func validate(name: String) throws {
            try self.authorizedTokenIssuerList?.forEach {
                try $0.validate(name: "\(name).authorizedTokenIssuerList[]")
            }
            try self.validate(self.iamRoleArn, name: "iamRoleArn", parent: name, max: 2147483647)
            try self.validate(self.idcDisplayName, name: "idcDisplayName", parent: name, max: 127)
            try self.validate(self.idcDisplayName, name: "idcDisplayName", parent: name, min: 1)
            try self.validate(self.idcDisplayName, name: "idcDisplayName", parent: name, pattern: "^[\\w+=,.@-]+$")
            try self.validate(self.idcInstanceArn, name: "idcInstanceArn", parent: name, max: 2147483647)
            try self.validate(self.identityNamespace, name: "identityNamespace", parent: name, max: 127)
            try self.validate(self.identityNamespace, name: "identityNamespace", parent: name, min: 1)
            try self.validate(self.identityNamespace, name: "identityNamespace", parent: name, pattern: "^[a-zA-Z0-9_+.#@$-]+$")
            try self.validate(self.redshiftIdcApplicationName, name: "redshiftIdcApplicationName", parent: name, max: 63)
            try self.validate(self.redshiftIdcApplicationName, name: "redshiftIdcApplicationName", parent: name, min: 1)
            try self.validate(self.redshiftIdcApplicationName, name: "redshiftIdcApplicationName", parent: name, pattern: "^[a-z][a-z0-9]*(-[a-z0-9]+)*$")
        }

        private enum CodingKeys: String, CodingKey {
            case authorizedTokenIssuerList = "AuthorizedTokenIssuerList"
            case iamRoleArn = "IamRoleArn"
            case idcDisplayName = "IdcDisplayName"
            case idcInstanceArn = "IdcInstanceArn"
            case identityNamespace = "IdentityNamespace"
            case redshiftIdcApplicationName = "RedshiftIdcApplicationName"
            case serviceIntegrations = "ServiceIntegrations"
        }
    }

    public struct CreateRedshiftIdcApplicationResult: AWSDecodableShape {
        public let redshiftIdcApplication: RedshiftIdcApplication?

        @inlinable
        public init(redshiftIdcApplication: RedshiftIdcApplication? = nil) {
            self.redshiftIdcApplication = redshiftIdcApplication
        }

        private enum CodingKeys: String, CodingKey {
            case redshiftIdcApplication = "RedshiftIdcApplication"
        }
    }

    public struct CreateScheduledActionMessage: AWSEncodableShape {
        /// If true, the schedule is enabled. If false, the scheduled action does not trigger.  For more information about state of the scheduled action, see ScheduledAction.
        public let enable: Bool?
        /// The end time in UTC of the scheduled action. After this time, the scheduled action does not trigger.  For more information about this parameter, see ScheduledAction.
        public let endTime: Date?
        /// The IAM role to assume to run the target action.  For more information about this parameter, see ScheduledAction.
        public let iamRole: String?
        /// The schedule in at( ) or cron( ) format.  For more information about this parameter, see ScheduledAction.
        public let schedule: String?
        /// The description of the scheduled action.
        public let scheduledActionDescription: String?
        /// The name of the scheduled action. The name must be unique within an account.  For more information about this parameter, see ScheduledAction.
        public let scheduledActionName: String?
        /// The start time in UTC of the scheduled action.  Before this time, the scheduled action does not trigger. For more information about this parameter, see ScheduledAction.
        public let startTime: Date?
        /// A JSON format string of the Amazon Redshift API operation with input parameters.  For more information about this parameter, see ScheduledAction.
        public let targetAction: ScheduledActionType?

        @inlinable
        public init(enable: Bool? = nil, endTime: Date? = nil, iamRole: String? = nil, schedule: String? = nil, scheduledActionDescription: String? = nil, scheduledActionName: String? = nil, startTime: Date? = nil, targetAction: ScheduledActionType? = nil) {
            self.enable = enable
            self.endTime = endTime
            self.iamRole = iamRole
            self.schedule = schedule
            self.scheduledActionDescription = scheduledActionDescription
            self.scheduledActionName = scheduledActionName
            self.startTime = startTime
            self.targetAction = targetAction
        }

        public func validate(name: String) throws {
            try self.validate(self.iamRole, name: "iamRole", parent: name, max: 2147483647)
            try self.validate(self.schedule, name: "schedule", parent: name, max: 2147483647)
            try self.validate(self.scheduledActionDescription, name: "scheduledActionDescription", parent: name, max: 2147483647)
            try self.validate(self.scheduledActionName, name: "scheduledActionName", parent: name, max: 2147483647)
            try self.targetAction?.validate(name: "\(name).targetAction")
        }

        private enum CodingKeys: String, CodingKey {
            case enable = "Enable"
            case endTime = "EndTime"
            case iamRole = "IamRole"
            case schedule = "Schedule"
            case scheduledActionDescription = "ScheduledActionDescription"
            case scheduledActionName = "ScheduledActionName"
            case startTime = "StartTime"
            case targetAction = "TargetAction"
        }
    }

    public struct CreateSnapshotCopyGrantMessage: AWSEncodableShape {
        public struct _TagsEncoding: ArrayCoderProperties { public static let member = "Tag" }

        /// The unique identifier of the encrypted symmetric key to which to grant Amazon Redshift permission. If no key is specified, the default key is used.
        public let kmsKeyId: String?
        /// The name of the snapshot copy grant. This name must be unique in the region for the Amazon Web Services account. Constraints:   Must contain from 1 to 63 alphanumeric characters or hyphens.   Alphabetic characters must be lowercase.   First character must be a letter.   Cannot end with a hyphen or contain two consecutive hyphens.   Must be unique for all clusters within an Amazon Web Services account.
        public let snapshotCopyGrantName: String?
        /// A list of tag instances.
        @OptionalCustomCoding<ArrayCoder<_TagsEncoding, Tag>>
        public var tags: [Tag]?

        @inlinable
        public init(kmsKeyId: String? = nil, snapshotCopyGrantName: String? = nil, tags: [Tag]? = nil) {
            self.kmsKeyId = kmsKeyId
            self.snapshotCopyGrantName = snapshotCopyGrantName
            self.tags = tags
        }

        public func validate(name: String) throws {
            try self.validate(self.kmsKeyId, name: "kmsKeyId", parent: name, max: 2147483647)
            try self.validate(self.snapshotCopyGrantName, name: "snapshotCopyGrantName", parent: name, max: 2147483647)
            try self.tags?.forEach {
                try $0.validate(name: "\(name).tags[]")
            }
        }

        private enum CodingKeys: String, CodingKey {
            case kmsKeyId = "KmsKeyId"
            case snapshotCopyGrantName = "SnapshotCopyGrantName"
            case tags = "Tags"
        }
    }

    public struct CreateSnapshotCopyGrantResult: AWSDecodableShape {
        public let snapshotCopyGrant: SnapshotCopyGrant?

        @inlinable
        public init(snapshotCopyGrant: SnapshotCopyGrant? = nil) {
            self.snapshotCopyGrant = snapshotCopyGrant
        }

        private enum CodingKeys: String, CodingKey {
            case snapshotCopyGrant = "SnapshotCopyGrant"
        }
    }

    public struct CreateSnapshotScheduleMessage: AWSEncodableShape {
        public struct _ScheduleDefinitionsEncoding: ArrayCoderProperties { public static let member = "ScheduleDefinition" }
        public struct _TagsEncoding: ArrayCoderProperties { public static let member = "Tag" }

        public let dryRun: Bool?
        public let nextInvocations: Int?
        /// The definition of the snapshot schedule. The definition is made up of schedule expressions, for example "cron(30 12 *)" or "rate(12 hours)".
        @OptionalCustomCoding<ArrayCoder<_ScheduleDefinitionsEncoding, String>>
        public var scheduleDefinitions: [String]?
        /// The description of the snapshot schedule.
        public let scheduleDescription: String?
        /// A unique identifier for a snapshot schedule. Only alphanumeric characters are allowed for the identifier.
        public let scheduleIdentifier: String?
        /// An optional set of tags you can use to search for the schedule.
        @OptionalCustomCoding<ArrayCoder<_TagsEncoding, Tag>>
        public var tags: [Tag]?

        @inlinable
        public init(dryRun: Bool? = nil, nextInvocations: Int? = nil, scheduleDefinitions: [String]? = nil, scheduleDescription: String? = nil, scheduleIdentifier: String? = nil, tags: [Tag]? = nil) {
            self.dryRun = dryRun
            self.nextInvocations = nextInvocations
            self.scheduleDefinitions = scheduleDefinitions
            self.scheduleDescription = scheduleDescription
            self.scheduleIdentifier = scheduleIdentifier
            self.tags = tags
        }

        public func validate(name: String) throws {
            try self.scheduleDefinitions?.forEach {
                try validate($0, name: "scheduleDefinitions[]", parent: name, max: 2147483647)
            }
            try self.validate(self.scheduleDescription, name: "scheduleDescription", parent: name, max: 2147483647)
            try self.validate(self.scheduleIdentifier, name: "scheduleIdentifier", parent: name, max: 2147483647)
            try self.tags?.forEach {
                try $0.validate(name: "\(name).tags[]")
            }
        }

        private enum CodingKeys: String, CodingKey {
            case dryRun = "DryRun"
            case nextInvocations = "NextInvocations"
            case scheduleDefinitions = "ScheduleDefinitions"
            case scheduleDescription = "ScheduleDescription"
            case scheduleIdentifier = "ScheduleIdentifier"
            case tags = "Tags"
        }
    }

    public struct CreateTagsMessage: AWSEncodableShape {
        public struct _TagsEncoding: ArrayCoderProperties { public static let member = "Tag" }

        /// The Amazon Resource Name (ARN) to which you want to add the tag or tags. For example, arn:aws:redshift:us-east-2:123456789:cluster:t1.
        public let resourceName: String?
        /// One or more name/value pairs to add as tags to the specified resource. Each tag name is passed in with the parameter Key and the corresponding value is passed in with the parameter Value. The Key and Value parameters are separated by a comma (,). Separate multiple tags with a space. For example, --tags "Key"="owner","Value"="admin" "Key"="environment","Value"="test" "Key"="version","Value"="1.0".
        @OptionalCustomCoding<ArrayCoder<_TagsEncoding, Tag>>
        public var tags: [Tag]?

        @inlinable
        public init(resourceName: String? = nil, tags: [Tag]? = nil) {
            self.resourceName = resourceName
            self.tags = tags
        }

        public func validate(name: String) throws {
            try self.validate(self.resourceName, name: "resourceName", parent: name, max: 2147483647)
            try self.tags?.forEach {
                try $0.validate(name: "\(name).tags[]")
            }
        }

        private enum CodingKeys: String, CodingKey {
            case resourceName = "ResourceName"
            case tags = "Tags"
        }
    }

    public struct CreateUsageLimitMessage: AWSEncodableShape {
        public struct _TagsEncoding: ArrayCoderProperties { public static let member = "Tag" }

        /// The limit amount. If time-based, this amount is in minutes. If data-based, this amount is in terabytes (TB). The value must be a positive number.
        public let amount: Int64?
        /// The action that Amazon Redshift takes when the limit is reached. The default is log.  For more information about this parameter, see UsageLimit.
        public let breachAction: UsageLimitBreachAction?
        /// The identifier of the cluster that you want to limit usage.
        public let clusterIdentifier: String?
        /// The Amazon Redshift feature that you want to limit.
        public let featureType: UsageLimitFeatureType?
        /// The type of limit. Depending on the feature type, this can be based on a time duration or data size. If FeatureType is spectrum, then LimitType must be data-scanned. If FeatureType is concurrency-scaling, then LimitType must be time. If FeatureType is cross-region-datasharing, then LimitType must be data-scanned.
        public let limitType: UsageLimitLimitType?
        /// The time period that the amount applies to. A weekly period begins on Sunday. The default is monthly.
        public let period: UsageLimitPeriod?
        /// A list of tag instances.
        @OptionalCustomCoding<ArrayCoder<_TagsEncoding, Tag>>
        public var tags: [Tag]?

        @inlinable
        public init(amount: Int64? = nil, breachAction: UsageLimitBreachAction? = nil, clusterIdentifier: String? = nil, featureType: UsageLimitFeatureType? = nil, limitType: UsageLimitLimitType? = nil, period: UsageLimitPeriod? = nil, tags: [Tag]? = nil) {
            self.amount = amount
            self.breachAction = breachAction
            self.clusterIdentifier = clusterIdentifier
            self.featureType = featureType
            self.limitType = limitType
            self.period = period
            self.tags = tags
        }

        public func validate(name: String) throws {
            try self.validate(self.clusterIdentifier, name: "clusterIdentifier", parent: name, max: 2147483647)
            try self.tags?.forEach {
                try $0.validate(name: "\(name).tags[]")
            }
        }

        private enum CodingKeys: String, CodingKey {
            case amount = "Amount"
            case breachAction = "BreachAction"
            case clusterIdentifier = "ClusterIdentifier"
            case featureType = "FeatureType"
            case limitType = "LimitType"
            case period = "Period"
            case tags = "Tags"
        }
    }

    public struct CustomDomainAssociationsMessage: AWSDecodableShape {
        public struct _AssociationsEncoding: ArrayCoderProperties { public static let member = "Association" }

        /// The associations for the custom domain.
        @OptionalCustomCoding<ArrayCoder<_AssociationsEncoding, Association>>
        public var associations: [Association]?
        /// The marker for the custom domain association.
        public let marker: String?

        @inlinable
        public init(associations: [Association]? = nil, marker: String? = nil) {
            self.associations = associations
            self.marker = marker
        }

        private enum CodingKeys: String, CodingKey {
            case associations = "Associations"
            case marker = "Marker"
        }
    }

    public struct CustomerStorageMessage: AWSDecodableShape {
        /// The total amount of storage currently used for snapshots.
        public let totalBackupSizeInMegaBytes: Double?
        /// The total amount of storage currently provisioned.
        public let totalProvisionedStorageInMegaBytes: Double?

        @inlinable
        public init(totalBackupSizeInMegaBytes: Double? = nil, totalProvisionedStorageInMegaBytes: Double? = nil) {
            self.totalBackupSizeInMegaBytes = totalBackupSizeInMegaBytes
            self.totalProvisionedStorageInMegaBytes = totalProvisionedStorageInMegaBytes
        }

        private enum CodingKeys: String, CodingKey {
            case totalBackupSizeInMegaBytes = "TotalBackupSizeInMegaBytes"
            case totalProvisionedStorageInMegaBytes = "TotalProvisionedStorageInMegaBytes"
        }
    }

    public struct DataShare: AWSDecodableShape {
        /// A value that specifies whether the datashare can be shared to a publicly accessible  cluster.
        public let allowPubliclyAccessibleConsumers: Bool?
        /// The Amazon Resource Name (ARN) of the datashare that the consumer is to use.
        public let dataShareArn: String?
        /// A value that specifies when the datashare has an association between producer and data consumers.
        @OptionalCustomCoding<StandardArrayCoder<DataShareAssociation>>
        public var dataShareAssociations: [DataShareAssociation]?
        ///  The type of the datashare created by RegisterNamespace.
        public let dataShareType: DataShareType?
        /// The identifier of a datashare to show its managing entity.
        public let managedBy: String?
        /// The Amazon Resource Name (ARN) of the producer namespace.
        public let producerArn: String?

        @inlinable
        public init(allowPubliclyAccessibleConsumers: Bool? = nil, dataShareArn: String? = nil, dataShareAssociations: [DataShareAssociation]? = nil, dataShareType: DataShareType? = nil, managedBy: String? = nil, producerArn: String? = nil) {
            self.allowPubliclyAccessibleConsumers = allowPubliclyAccessibleConsumers
            self.dataShareArn = dataShareArn
            self.dataShareAssociations = dataShareAssociations
            self.dataShareType = dataShareType
            self.managedBy = managedBy
            self.producerArn = producerArn
        }

        private enum CodingKeys: String, CodingKey {
            case allowPubliclyAccessibleConsumers = "AllowPubliclyAccessibleConsumers"
            case dataShareArn = "DataShareArn"
            case dataShareAssociations = "DataShareAssociations"
            case dataShareType = "DataShareType"
            case managedBy = "ManagedBy"
            case producerArn = "ProducerArn"
        }
    }

    public struct DataShareAssociation: AWSDecodableShape {
        /// Specifies whether write operations were allowed during data share association.
        public let consumerAcceptedWrites: Bool?
        /// The name of the consumer accounts that have an association with a producer datashare.
        public let consumerIdentifier: String?
        /// The Amazon Web Services Region of the consumer accounts that have an association with a producer datashare.
        public let consumerRegion: String?
        /// The creation date of the datashare that is associated.
        public let createdDate: Date?
        /// Specifies whether write operations were allowed during data share authorization.
        public let producerAllowedWrites: Bool?
        /// The status of the datashare that is associated.
        public let status: DataShareStatus?
        /// The status change data of the datashare that is associated.
        public let statusChangeDate: Date?

        @inlinable
        public init(consumerAcceptedWrites: Bool? = nil, consumerIdentifier: String? = nil, consumerRegion: String? = nil, createdDate: Date? = nil, producerAllowedWrites: Bool? = nil, status: DataShareStatus? = nil, statusChangeDate: Date? = nil) {
            self.consumerAcceptedWrites = consumerAcceptedWrites
            self.consumerIdentifier = consumerIdentifier
            self.consumerRegion = consumerRegion
            self.createdDate = createdDate
            self.producerAllowedWrites = producerAllowedWrites
            self.status = status
            self.statusChangeDate = statusChangeDate
        }

        private enum CodingKeys: String, CodingKey {
            case consumerAcceptedWrites = "ConsumerAcceptedWrites"
            case consumerIdentifier = "ConsumerIdentifier"
            case consumerRegion = "ConsumerRegion"
            case createdDate = "CreatedDate"
            case producerAllowedWrites = "ProducerAllowedWrites"
            case status = "Status"
            case statusChangeDate = "StatusChangeDate"
        }
    }

    public struct DataTransferProgress: AWSDecodableShape {
        /// Describes the data transfer rate in MB's per second.
        public let currentRateInMegaBytesPerSecond: Double?
        /// Describes the total amount of data that has been transfered in MB's.
        public let dataTransferredInMegaBytes: Int64?
        /// Describes the number of seconds that have elapsed during the data transfer.
        public let elapsedTimeInSeconds: Int64?
        /// Describes the estimated number of seconds remaining to complete the transfer.
        public let estimatedTimeToCompletionInSeconds: Int64?
        /// Describes the status of the cluster. While the transfer is in progress the status is transferringdata.
        public let status: String?
        /// Describes the total amount of data to be transfered in megabytes.
        public let totalDataInMegaBytes: Int64?

        @inlinable
        public init(currentRateInMegaBytesPerSecond: Double? = nil, dataTransferredInMegaBytes: Int64? = nil, elapsedTimeInSeconds: Int64? = nil, estimatedTimeToCompletionInSeconds: Int64? = nil, status: String? = nil, totalDataInMegaBytes: Int64? = nil) {
            self.currentRateInMegaBytesPerSecond = currentRateInMegaBytesPerSecond
            self.dataTransferredInMegaBytes = dataTransferredInMegaBytes
            self.elapsedTimeInSeconds = elapsedTimeInSeconds
            self.estimatedTimeToCompletionInSeconds = estimatedTimeToCompletionInSeconds
            self.status = status
            self.totalDataInMegaBytes = totalDataInMegaBytes
        }

        private enum CodingKeys: String, CodingKey {
            case currentRateInMegaBytesPerSecond = "CurrentRateInMegaBytesPerSecond"
            case dataTransferredInMegaBytes = "DataTransferredInMegaBytes"
            case elapsedTimeInSeconds = "ElapsedTimeInSeconds"
            case estimatedTimeToCompletionInSeconds = "EstimatedTimeToCompletionInSeconds"
            case status = "Status"
            case totalDataInMegaBytes = "TotalDataInMegaBytes"
        }
    }

    public struct DeauthorizeDataShareMessage: AWSEncodableShape {
        /// The identifier of the data consumer that is to have authorization removed from the datashare.  This identifier is an Amazon Web Services account ID or a keyword, such as ADX.
        public let consumerIdentifier: String?
        /// The namespace Amazon Resource Name (ARN) of the datashare to remove authorization from.
        public let dataShareArn: String?

        @inlinable
        public init(consumerIdentifier: String? = nil, dataShareArn: String? = nil) {
            self.consumerIdentifier = consumerIdentifier
            self.dataShareArn = dataShareArn
        }

        public func validate(name: String) throws {
            try self.validate(self.consumerIdentifier, name: "consumerIdentifier", parent: name, max: 2147483647)
            try self.validate(self.dataShareArn, name: "dataShareArn", parent: name, max: 2147483647)
        }

        private enum CodingKeys: String, CodingKey {
            case consumerIdentifier = "ConsumerIdentifier"
            case dataShareArn = "DataShareArn"
        }
    }

    public struct DefaultClusterParameters: AWSDecodableShape {
        public struct _ParametersEncoding: ArrayCoderProperties { public static let member = "Parameter" }

        /// A value that indicates the starting point for the next set of response records in a subsequent request. If a value is returned in a response, you can retrieve the next set of records by providing this returned marker value in the Marker parameter and retrying the command. If the Marker field is empty, all response records have been retrieved for the request.
        public let marker: String?
        /// The name of the cluster parameter group family to which the engine default parameters apply.
        public let parameterGroupFamily: String?
        /// The list of cluster default parameters.
        @OptionalCustomCoding<ArrayCoder<_ParametersEncoding, Parameter>>
        public var parameters: [Parameter]?

        @inlinable
        public init(marker: String? = nil, parameterGroupFamily: String? = nil, parameters: [Parameter]? = nil) {
            self.marker = marker
            self.parameterGroupFamily = parameterGroupFamily
            self.parameters = parameters
        }

        private enum CodingKeys: String, CodingKey {
            case marker = "Marker"
            case parameterGroupFamily = "ParameterGroupFamily"
            case parameters = "Parameters"
        }
    }

    public struct DeferredMaintenanceWindow: AWSDecodableShape {
        ///  A timestamp for the end of the time period when we defer maintenance.
        public let deferMaintenanceEndTime: Date?
        /// A unique identifier for the maintenance window.
        public let deferMaintenanceIdentifier: String?
        ///  A timestamp for the beginning of the time period when we defer maintenance.
        public let deferMaintenanceStartTime: Date?

        @inlinable
        public init(deferMaintenanceEndTime: Date? = nil, deferMaintenanceIdentifier: String? = nil, deferMaintenanceStartTime: Date? = nil) {
            self.deferMaintenanceEndTime = deferMaintenanceEndTime
            self.deferMaintenanceIdentifier = deferMaintenanceIdentifier
            self.deferMaintenanceStartTime = deferMaintenanceStartTime
        }

        private enum CodingKeys: String, CodingKey {
            case deferMaintenanceEndTime = "DeferMaintenanceEndTime"
            case deferMaintenanceIdentifier = "DeferMaintenanceIdentifier"
            case deferMaintenanceStartTime = "DeferMaintenanceStartTime"
        }
    }

    public struct DeleteAuthenticationProfileMessage: AWSEncodableShape {
        /// The name of the authentication profile to delete.
        public let authenticationProfileName: String?

        @inlinable
        public init(authenticationProfileName: String? = nil) {
            self.authenticationProfileName = authenticationProfileName
        }

        public func validate(name: String) throws {
            try self.validate(self.authenticationProfileName, name: "authenticationProfileName", parent: name, max: 63)
            try self.validate(self.authenticationProfileName, name: "authenticationProfileName", parent: name, pattern: "^[a-zA-Z0-9\\-]+$")
        }

        private enum CodingKeys: String, CodingKey {
            case authenticationProfileName = "AuthenticationProfileName"
        }
    }

    public struct DeleteAuthenticationProfileResult: AWSDecodableShape {
        /// The name of the authentication profile that was deleted.
        public let authenticationProfileName: String?

        @inlinable
        public init(authenticationProfileName: String? = nil) {
            self.authenticationProfileName = authenticationProfileName
        }

        private enum CodingKeys: String, CodingKey {
            case authenticationProfileName = "AuthenticationProfileName"
        }
    }

    public struct DeleteClusterMessage: AWSEncodableShape {
        /// The identifier of the cluster to be deleted. Constraints:   Must contain lowercase characters.   Must contain from 1 to 63 alphanumeric characters or hyphens.   First character must be a letter.   Cannot end with a hyphen or contain two consecutive hyphens.
        public let clusterIdentifier: String?
        /// The identifier of the final snapshot that is to be created immediately before deleting the cluster. If this parameter is provided, SkipFinalClusterSnapshot must be false.  Constraints:   Must be 1 to 255 alphanumeric characters.   First character must be a letter.   Cannot end with a hyphen or contain two consecutive hyphens.
        public let finalClusterSnapshotIdentifier: String?
        /// The number of days that a manual snapshot is retained. If the value is -1, the manual snapshot is retained indefinitely. The value must be either -1 or an integer between 1 and 3,653. The default value is -1.
        public let finalClusterSnapshotRetentionPeriod: Int?
        /// Determines whether a final snapshot of the cluster is created before Amazon Redshift deletes the cluster. If true, a final cluster snapshot is not created. If false, a final cluster snapshot is created before the cluster is deleted.   The FinalClusterSnapshotIdentifier parameter must be specified if SkipFinalClusterSnapshot is false.  Default: false
        public let skipFinalClusterSnapshot: Bool?

        @inlinable
        public init(clusterIdentifier: String? = nil, finalClusterSnapshotIdentifier: String? = nil, finalClusterSnapshotRetentionPeriod: Int? = nil, skipFinalClusterSnapshot: Bool? = nil) {
            self.clusterIdentifier = clusterIdentifier
            self.finalClusterSnapshotIdentifier = finalClusterSnapshotIdentifier
            self.finalClusterSnapshotRetentionPeriod = finalClusterSnapshotRetentionPeriod
            self.skipFinalClusterSnapshot = skipFinalClusterSnapshot
        }

        public func validate(name: String) throws {
            try self.validate(self.clusterIdentifier, name: "clusterIdentifier", parent: name, max: 2147483647)
            try self.validate(self.finalClusterSnapshotIdentifier, name: "finalClusterSnapshotIdentifier", parent: name, max: 2147483647)
        }

        private enum CodingKeys: String, CodingKey {
            case clusterIdentifier = "ClusterIdentifier"
            case finalClusterSnapshotIdentifier = "FinalClusterSnapshotIdentifier"
            case finalClusterSnapshotRetentionPeriod = "FinalClusterSnapshotRetentionPeriod"
            case skipFinalClusterSnapshot = "SkipFinalClusterSnapshot"
        }
    }

    public struct DeleteClusterParameterGroupMessage: AWSEncodableShape {
        /// The name of the parameter group to be deleted. Constraints:   Must be the name of an existing cluster parameter group.   Cannot delete a default cluster parameter group.
        public let parameterGroupName: String?

        @inlinable
        public init(parameterGroupName: String? = nil) {
            self.parameterGroupName = parameterGroupName
        }

        public func validate(name: String) throws {
            try self.validate(self.parameterGroupName, name: "parameterGroupName", parent: name, max: 2147483647)
        }

        private enum CodingKeys: String, CodingKey {
            case parameterGroupName = "ParameterGroupName"
        }
    }

    public struct DeleteClusterResult: AWSDecodableShape {
        public let cluster: Cluster?

        @inlinable
        public init(cluster: Cluster? = nil) {
            self.cluster = cluster
        }

        private enum CodingKeys: String, CodingKey {
            case cluster = "Cluster"
        }
    }

    public struct DeleteClusterSecurityGroupMessage: AWSEncodableShape {
        /// The name of the cluster security group to be deleted.
        public let clusterSecurityGroupName: String?

        @inlinable
        public init(clusterSecurityGroupName: String? = nil) {
            self.clusterSecurityGroupName = clusterSecurityGroupName
        }

        public func validate(name: String) throws {
            try self.validate(self.clusterSecurityGroupName, name: "clusterSecurityGroupName", parent: name, max: 2147483647)
        }

        private enum CodingKeys: String, CodingKey {
            case clusterSecurityGroupName = "ClusterSecurityGroupName"
        }
    }

    public struct DeleteClusterSnapshotMessage: AWSEncodableShape {
        /// The unique identifier of the cluster the snapshot was created from. This parameter is required if your IAM user has a policy containing a snapshot resource element that specifies anything other than * for the cluster name. Constraints: Must be the name of valid cluster.
        public let snapshotClusterIdentifier: String?
        /// The unique identifier of the manual snapshot to be deleted. Constraints: Must be the name of an existing snapshot that is in the available, failed, or cancelled state.
        public let snapshotIdentifier: String?

        @inlinable
        public init(snapshotClusterIdentifier: String? = nil, snapshotIdentifier: String? = nil) {
            self.snapshotClusterIdentifier = snapshotClusterIdentifier
            self.snapshotIdentifier = snapshotIdentifier
        }

        public func validate(name: String) throws {
            try self.validate(self.snapshotClusterIdentifier, name: "snapshotClusterIdentifier", parent: name, max: 2147483647)
            try self.validate(self.snapshotIdentifier, name: "snapshotIdentifier", parent: name, max: 2147483647)
        }

        private enum CodingKeys: String, CodingKey {
            case snapshotClusterIdentifier = "SnapshotClusterIdentifier"
            case snapshotIdentifier = "SnapshotIdentifier"
        }
    }

    public struct DeleteClusterSnapshotResult: AWSDecodableShape {
        public let snapshot: Snapshot?

        @inlinable
        public init(snapshot: Snapshot? = nil) {
            self.snapshot = snapshot
        }

        private enum CodingKeys: String, CodingKey {
            case snapshot = "Snapshot"
        }
    }

    public struct DeleteClusterSubnetGroupMessage: AWSEncodableShape {
        /// The name of the cluster subnet group name to be deleted.
        public let clusterSubnetGroupName: String?

        @inlinable
        public init(clusterSubnetGroupName: String? = nil) {
            self.clusterSubnetGroupName = clusterSubnetGroupName
        }

        public func validate(name: String) throws {
            try self.validate(self.clusterSubnetGroupName, name: "clusterSubnetGroupName", parent: name, max: 2147483647)
        }

        private enum CodingKeys: String, CodingKey {
            case clusterSubnetGroupName = "ClusterSubnetGroupName"
        }
    }

    public struct DeleteCustomDomainAssociationMessage: AWSEncodableShape {
        /// The identifier of the cluster to delete a custom domain association for.
        public let clusterIdentifier: String?
        /// The custom domain name for the custom domain association.
        public let customDomainName: String?

        @inlinable
        public init(clusterIdentifier: String? = nil, customDomainName: String? = nil) {
            self.clusterIdentifier = clusterIdentifier
            self.customDomainName = customDomainName
        }

        public func validate(name: String) throws {
            try self.validate(self.clusterIdentifier, name: "clusterIdentifier", parent: name, max: 2147483647)
            try self.validate(self.customDomainName, name: "customDomainName", parent: name, max: 253)
            try self.validate(self.customDomainName, name: "customDomainName", parent: name, min: 1)
            try self.validate(self.customDomainName, name: "customDomainName", parent: name, pattern: "^(((?!-)[A-Za-z0-9-]{0,62}[A-Za-z0-9])\\.)+((?!-)[A-Za-z0-9-]{1,62}[A-Za-z0-9])$")
        }

        private enum CodingKeys: String, CodingKey {
            case clusterIdentifier = "ClusterIdentifier"
            case customDomainName = "CustomDomainName"
        }
    }

    public struct DeleteEndpointAccessMessage: AWSEncodableShape {
        /// The Redshift-managed VPC endpoint to delete.
        public let endpointName: String?

        @inlinable
        public init(endpointName: String? = nil) {
            self.endpointName = endpointName
        }

        public func validate(name: String) throws {
            try self.validate(self.endpointName, name: "endpointName", parent: name, max: 2147483647)
        }

        private enum CodingKeys: String, CodingKey {
            case endpointName = "EndpointName"
        }
    }

    public struct DeleteEventSubscriptionMessage: AWSEncodableShape {
        /// The name of the Amazon Redshift event notification subscription to be deleted.
        public let subscriptionName: String?

        @inlinable
        public init(subscriptionName: String? = nil) {
            self.subscriptionName = subscriptionName
        }

        public func validate(name: String) throws {
            try self.validate(self.subscriptionName, name: "subscriptionName", parent: name, max: 2147483647)
        }

        private enum CodingKeys: String, CodingKey {
            case subscriptionName = "SubscriptionName"
        }
    }

    public struct DeleteHsmClientCertificateMessage: AWSEncodableShape {
        /// The identifier of the HSM client certificate to be deleted.
        public let hsmClientCertificateIdentifier: String?

        @inlinable
        public init(hsmClientCertificateIdentifier: String? = nil) {
            self.hsmClientCertificateIdentifier = hsmClientCertificateIdentifier
        }

        public func validate(name: String) throws {
            try self.validate(self.hsmClientCertificateIdentifier, name: "hsmClientCertificateIdentifier", parent: name, max: 2147483647)
        }

        private enum CodingKeys: String, CodingKey {
            case hsmClientCertificateIdentifier = "HsmClientCertificateIdentifier"
        }
    }

    public struct DeleteHsmConfigurationMessage: AWSEncodableShape {
        /// The identifier of the Amazon Redshift HSM configuration to be deleted.
        public let hsmConfigurationIdentifier: String?

        @inlinable
        public init(hsmConfigurationIdentifier: String? = nil) {
            self.hsmConfigurationIdentifier = hsmConfigurationIdentifier
        }

        public func validate(name: String) throws {
            try self.validate(self.hsmConfigurationIdentifier, name: "hsmConfigurationIdentifier", parent: name, max: 2147483647)
        }

        private enum CodingKeys: String, CodingKey {
            case hsmConfigurationIdentifier = "HsmConfigurationIdentifier"
        }
    }

    public struct DeleteIntegrationMessage: AWSEncodableShape {
        /// The unique identifier of the integration to delete.
        public let integrationArn: String?

        @inlinable
        public init(integrationArn: String? = nil) {
            self.integrationArn = integrationArn
        }

        public func validate(name: String) throws {
            try self.validate(self.integrationArn, name: "integrationArn", parent: name, max: 255)
            try self.validate(self.integrationArn, name: "integrationArn", parent: name, min: 1)
            try self.validate(self.integrationArn, name: "integrationArn", parent: name, pattern: "^arn:aws[a-z\\-]*:redshift:[a-z0-9\\-]*:[0-9]*:integration:[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$")
        }

        private enum CodingKeys: String, CodingKey {
            case integrationArn = "IntegrationArn"
        }
    }

    public struct DeleteRedshiftIdcApplicationMessage: AWSEncodableShape {
        /// The ARN for a deleted Amazon Redshift IAM Identity Center application.
        public let redshiftIdcApplicationArn: String?

        @inlinable
        public init(redshiftIdcApplicationArn: String? = nil) {
            self.redshiftIdcApplicationArn = redshiftIdcApplicationArn
        }

        public func validate(name: String) throws {
            try self.validate(self.redshiftIdcApplicationArn, name: "redshiftIdcApplicationArn", parent: name, max: 2147483647)
        }

        private enum CodingKeys: String, CodingKey {
            case redshiftIdcApplicationArn = "RedshiftIdcApplicationArn"
        }
    }

    public struct DeleteResourcePolicyMessage: AWSEncodableShape {
        /// The Amazon Resource Name (ARN) of the resource of which its resource policy is deleted.
        public let resourceArn: String?

        @inlinable
        public init(resourceArn: String? = nil) {
            self.resourceArn = resourceArn
        }

        public func validate(name: String) throws {
            try self.validate(self.resourceArn, name: "resourceArn", parent: name, max: 2147483647)
        }

        private enum CodingKeys: String, CodingKey {
            case resourceArn = "ResourceArn"
        }
    }

    public struct DeleteScheduledActionMessage: AWSEncodableShape {
        /// The name of the scheduled action to delete.
        public let scheduledActionName: String?

        @inlinable
        public init(scheduledActionName: String? = nil) {
            self.scheduledActionName = scheduledActionName
        }

        public func validate(name: String) throws {
            try self.validate(self.scheduledActionName, name: "scheduledActionName", parent: name, max: 2147483647)
        }

        private enum CodingKeys: String, CodingKey {
            case scheduledActionName = "ScheduledActionName"
        }
    }

    public struct DeleteSnapshotCopyGrantMessage: AWSEncodableShape {
        /// The name of the snapshot copy grant to delete.
        public let snapshotCopyGrantName: String?

        @inlinable
        public init(snapshotCopyGrantName: String? = nil) {
            self.snapshotCopyGrantName = snapshotCopyGrantName
        }

        public func validate(name: String) throws {
            try self.validate(self.snapshotCopyGrantName, name: "snapshotCopyGrantName", parent: name, max: 2147483647)
        }

        private enum CodingKeys: String, CodingKey {
            case snapshotCopyGrantName = "SnapshotCopyGrantName"
        }
    }

    public struct DeleteSnapshotScheduleMessage: AWSEncodableShape {
        /// A unique identifier of the snapshot schedule to delete.
        public let scheduleIdentifier: String?

        @inlinable
        public init(scheduleIdentifier: String? = nil) {
            self.scheduleIdentifier = scheduleIdentifier
        }

        public func validate(name: String) throws {
            try self.validate(self.scheduleIdentifier, name: "scheduleIdentifier", parent: name, max: 2147483647)
        }

        private enum CodingKeys: String, CodingKey {
            case scheduleIdentifier = "ScheduleIdentifier"
        }
    }

    public struct DeleteTagsMessage: AWSEncodableShape {
        public struct _TagKeysEncoding: ArrayCoderProperties { public static let member = "TagKey" }

        /// The Amazon Resource Name (ARN) from which you want to remove the tag or tags. For example, arn:aws:redshift:us-east-2:123456789:cluster:t1.
        public let resourceName: String?
        /// The tag key that you want to delete.
        @OptionalCustomCoding<ArrayCoder<_TagKeysEncoding, String>>
        public var tagKeys: [String]?

        @inlinable
        public init(resourceName: String? = nil, tagKeys: [String]? = nil) {
            self.resourceName = resourceName
            self.tagKeys = tagKeys
        }

        public func validate(name: String) throws {
            try self.validate(self.resourceName, name: "resourceName", parent: name, max: 2147483647)
            try self.tagKeys?.forEach {
                try validate($0, name: "tagKeys[]", parent: name, max: 2147483647)
            }
        }

        private enum CodingKeys: String, CodingKey {
            case resourceName = "ResourceName"
            case tagKeys = "TagKeys"
        }
    }

    public struct DeleteUsageLimitMessage: AWSEncodableShape {
        /// The identifier of the usage limit to delete.
        public let usageLimitId: String?

        @inlinable
        public init(usageLimitId: String? = nil) {
            self.usageLimitId = usageLimitId
        }

        public func validate(name: String) throws {
            try self.validate(self.usageLimitId, name: "usageLimitId", parent: name, max: 2147483647)
        }

        private enum CodingKeys: String, CodingKey {
            case usageLimitId = "UsageLimitId"
        }
    }

    public struct DeregisterNamespaceInputMessage: AWSEncodableShape {
        /// An array containing the ID of the consumer account  that you want to deregister the cluster or serverless namespace from.
        @OptionalCustomCoding<StandardArrayCoder<String>>
        public var consumerIdentifiers: [String]?
        /// The unique identifier of the cluster or  serverless namespace that you want to deregister.
        public let namespaceIdentifier: NamespaceIdentifierUnion?

        @inlinable
        public init(consumerIdentifiers: [String]? = nil, namespaceIdentifier: NamespaceIdentifierUnion? = nil) {
            self.consumerIdentifiers = consumerIdentifiers
            self.namespaceIdentifier = namespaceIdentifier
        }

        public func validate(name: String) throws {
            try self.consumerIdentifiers?.forEach {
                try validate($0, name: "consumerIdentifiers[]", parent: name, max: 2147483647)
            }
            try self.validate(self.consumerIdentifiers, name: "consumerIdentifiers", parent: name, max: 1)
            try self.validate(self.consumerIdentifiers, name: "consumerIdentifiers", parent: name, min: 1)
            try self.namespaceIdentifier?.validate(name: "\(name).namespaceIdentifier")
        }

        private enum CodingKeys: String, CodingKey {
            case consumerIdentifiers = "ConsumerIdentifiers"
            case namespaceIdentifier = "NamespaceIdentifier"
        }
    }

    public struct DeregisterNamespaceOutputMessage: AWSDecodableShape {
        /// The registration status of the cluster or  serverless namespace.
        public let status: NamespaceRegistrationStatus?

        @inlinable
        public init(status: NamespaceRegistrationStatus? = nil) {
            self.status = status
        }

        private enum CodingKeys: String, CodingKey {
            case status = "Status"
        }
    }

    public struct DescribeAccountAttributesMessage: AWSEncodableShape {
        public struct _AttributeNamesEncoding: ArrayCoderProperties { public static let member = "AttributeName" }

        /// A list of attribute names.
        @OptionalCustomCoding<ArrayCoder<_AttributeNamesEncoding, String>>
        public var attributeNames: [String]?

        @inlinable
        public init(attributeNames: [String]? = nil) {
            self.attributeNames = attributeNames
        }

        public func validate(name: String) throws {
            try self.attributeNames?.forEach {
                try validate($0, name: "attributeNames[]", parent: name, max: 2147483647)
            }
        }

        private enum CodingKeys: String, CodingKey {
            case attributeNames = "AttributeNames"
        }
    }

    public struct DescribeAuthenticationProfilesMessage: AWSEncodableShape {
        /// The name of the authentication profile to describe. If not specified then all authentication profiles owned by the account are listed.
        public let authenticationProfileName: String?

        @inlinable
        public init(authenticationProfileName: String? = nil) {
            self.authenticationProfileName = authenticationProfileName
        }

        public func validate(name: String) throws {
            try self.validate(self.authenticationProfileName, name: "authenticationProfileName", parent: name, max: 63)
            try self.validate(self.authenticationProfileName, name: "authenticationProfileName", parent: name, pattern: "^[a-zA-Z0-9\\-]+$")
        }

        private enum CodingKeys: String, CodingKey {
            case authenticationProfileName = "AuthenticationProfileName"
        }
    }

    public struct DescribeAuthenticationProfilesResult: AWSDecodableShape {
        /// The list of authentication profiles.
        @OptionalCustomCoding<StandardArrayCoder<AuthenticationProfile>>
        public var authenticationProfiles: [AuthenticationProfile]?

        @inlinable
        public init(authenticationProfiles: [AuthenticationProfile]? = nil) {
            self.authenticationProfiles = authenticationProfiles
        }

        private enum CodingKeys: String, CodingKey {
            case authenticationProfiles = "AuthenticationProfiles"
        }
    }

    public struct DescribeClusterDbRevisionsMessage: AWSEncodableShape {
        /// A unique identifier for a cluster whose ClusterDbRevisions you are requesting. This parameter is case sensitive. All clusters defined for an account are returned by default.
        public let clusterIdentifier: String?
        /// An optional parameter that specifies the starting point for returning a set of response records. When the results of a DescribeClusterDbRevisions request exceed the value specified in MaxRecords, Amazon Redshift returns a value in the marker field of the response. You can retrieve the next set of response records by providing the returned marker value in the marker parameter and retrying the request.  Constraints: You can specify either the ClusterIdentifier parameter, or the marker parameter, but not both.
        public let marker: String?
        /// The maximum number of response records to return in each call. If the number of remaining response records exceeds the specified MaxRecords value, a value is returned in the marker field of the response. You can retrieve the next set of response records by providing the returned marker value in the marker parameter and retrying the request.  Default: 100 Constraints: minimum 20, maximum 100.
        public let maxRecords: Int?

        @inlinable
        public init(clusterIdentifier: String? = nil, marker: String? = nil, maxRecords: Int? = nil) {
            self.clusterIdentifier = clusterIdentifier
            self.marker = marker
            self.maxRecords = maxRecords
        }

        public func validate(name: String) throws {
            try self.validate(self.clusterIdentifier, name: "clusterIdentifier", parent: name, max: 2147483647)
            try self.validate(self.marker, name: "marker", parent: name, max: 2147483647)
        }

        private enum CodingKeys: String, CodingKey {
            case clusterIdentifier = "ClusterIdentifier"
            case marker = "Marker"
            case maxRecords = "MaxRecords"
        }
    }

    public struct DescribeClusterParameterGroupsMessage: AWSEncodableShape {
        public struct _TagKeysEncoding: ArrayCoderProperties { public static let member = "TagKey" }
        public struct _TagValuesEncoding: ArrayCoderProperties { public static let member = "TagValue" }

        /// An optional parameter that specifies the starting point to return a set of response records. When the results of a DescribeClusterParameterGroups request exceed the value specified in MaxRecords, Amazon Web Services returns a value in the Marker field of the response. You can retrieve the next set of response records by providing the returned marker value in the Marker parameter and retrying the request.
        public let marker: String?
        /// The maximum number of response records to return in each call. If the number of remaining response records exceeds the specified MaxRecords value, a value is returned in a marker field of the response. You can retrieve the next set of records by retrying the command with the returned marker value.  Default: 100  Constraints: minimum 20, maximum 100.
        public let maxRecords: Int?
        /// The name of a specific parameter group for which to return details. By default, details about all parameter groups and the default parameter group are returned.
        public let parameterGroupName: String?
        /// A tag key or keys for which you want to return all matching cluster parameter groups that are associated with the specified key or keys. For example, suppose that you have parameter groups that are tagged with keys called owner and environment. If you specify both of these tag keys in the request, Amazon Redshift returns a response with the parameter groups that have either or both of these tag keys associated with them.
        @OptionalCustomCoding<ArrayCoder<_TagKeysEncoding, String>>
        public var tagKeys: [String]?
        /// A tag value or values for which you want to return all matching cluster parameter groups that are associated with the specified tag value or values. For example, suppose that you have parameter groups that are tagged with values called admin and test. If you specify both of these tag values in the request, Amazon Redshift returns a response with the parameter groups that have either or both of these tag values associated with them.
        @OptionalCustomCoding<ArrayCoder<_TagValuesEncoding, String>>
        public var tagValues: [String]?

        @inlinable
        public init(marker: String? = nil, maxRecords: Int? = nil, parameterGroupName: String? = nil, tagKeys: [String]? = nil, tagValues: [String]? = nil) {
            self.marker = marker
            self.maxRecords = maxRecords
            self.parameterGroupName = parameterGroupName
            self.tagKeys = tagKeys
            self.tagValues = tagValues
        }

        public func validate(name: String) throws {
            try self.validate(self.marker, name: "marker", parent: name, max: 2147483647)
            try self.validate(self.parameterGroupName, name: "parameterGroupName", parent: name, max: 2147483647)
            try self.tagKeys?.forEach {
                try validate($0, name: "tagKeys[]", parent: name, max: 2147483647)
            }
            try self.tagValues?.forEach {
                try validate($0, name: "tagValues[]", parent: name, max: 2147483647)
            }
        }

        private enum CodingKeys: String, CodingKey {
            case marker = "Marker"
            case maxRecords = "MaxRecords"
            case parameterGroupName = "ParameterGroupName"
            case tagKeys = "TagKeys"
            case tagValues = "TagValues"
        }
    }

    public struct DescribeClusterParametersMessage: AWSEncodableShape {
        /// An optional parameter that specifies the starting point to return a set of response records. When the results of a DescribeClusterParameters request exceed the value specified in MaxRecords, Amazon Web Services returns a value in the Marker field of the response. You can retrieve the next set of response records by providing the returned marker value in the Marker parameter and retrying the request.
        public let marker: String?
        /// The maximum number of response records to return in each call. If the number of remaining response records exceeds the specified MaxRecords value, a value is returned in a marker field of the response. You can retrieve the next set of records by retrying the command with the returned marker value.  Default: 100  Constraints: minimum 20, maximum 100.
        public let maxRecords: Int?
        /// The name of a cluster parameter group for which to return details.
        public let parameterGroupName: String?
        /// The parameter types to return. Specify user to show parameters that are different form the default. Similarly, specify engine-default to show parameters that are the same as the default parameter group.  Default: All parameter types returned. Valid Values: user | engine-default
        public let source: String?

        @inlinable
        public init(marker: String? = nil, maxRecords: Int? = nil, parameterGroupName: String? = nil, source: String? = nil) {
            self.marker = marker
            self.maxRecords = maxRecords
            self.parameterGroupName = parameterGroupName
            self.source = source
        }

        public func validate(name: String) throws {
            try self.validate(self.marker, name: "marker", parent: name, max: 2147483647)
            try self.validate(self.parameterGroupName, name: "parameterGroupName", parent: name, max: 2147483647)
            try self.validate(self.source, name: "source", parent: name, max: 2147483647)
        }

        private enum CodingKeys: String, CodingKey {
            case marker = "Marker"
            case maxRecords = "MaxRecords"
            case parameterGroupName = "ParameterGroupName"
            case source = "Source"
        }
    }

    public struct DescribeClusterSecurityGroupsMessage: AWSEncodableShape {
        public struct _TagKeysEncoding: ArrayCoderProperties { public static let member = "TagKey" }
        public struct _TagValuesEncoding: ArrayCoderProperties { public static let member = "TagValue" }

        /// The name of a cluster security group for which you are requesting details. You must specify either the Marker parameter or a ClusterSecurityGroupName parameter, but not both.  Example: securitygroup1
        public let clusterSecurityGroupName: String?
        /// An optional parameter that specifies the starting point to return a set of response records. When the results of a DescribeClusterSecurityGroups request exceed the value specified in MaxRecords, Amazon Web Services returns a value in the Marker field of the response. You can retrieve the next set of response records by providing the returned marker value in the Marker parameter and retrying the request.  Constraints: You must specify either the ClusterSecurityGroupName parameter or the Marker parameter, but not both.
        public let marker: String?
        /// The maximum number of response records to return in each call. If the number of remaining response records exceeds the specified MaxRecords value, a value is returned in a marker field of the response. You can retrieve the next set of records by retrying the command with the returned marker value.  Default: 100  Constraints: minimum 20, maximum 100.
        public let maxRecords: Int?
        /// A tag key or keys for which you want to return all matching cluster security groups that are associated with the specified key or keys. For example, suppose that you have security groups that are tagged with keys called owner and environment. If you specify both of these tag keys in the request, Amazon Redshift returns a response with the security groups that have either or both of these tag keys associated with them.
        @OptionalCustomCoding<ArrayCoder<_TagKeysEncoding, String>>
        public var tagKeys: [String]?
        /// A tag value or values for which you want to return all matching cluster security groups that are associated with the specified tag value or values. For example, suppose that you have security groups that are tagged with values called admin and test. If you specify both of these tag values in the request, Amazon Redshift returns a response with the security groups that have either or both of these tag values associated with them.
        @OptionalCustomCoding<ArrayCoder<_TagValuesEncoding, String>>
        public var tagValues: [String]?

        @inlinable
        public init(clusterSecurityGroupName: String? = nil, marker: String? = nil, maxRecords: Int? = nil, tagKeys: [String]? = nil, tagValues: [String]? = nil) {
            self.clusterSecurityGroupName = clusterSecurityGroupName
            self.marker = marker
            self.maxRecords = maxRecords
            self.tagKeys = tagKeys
            self.tagValues = tagValues
        }

        public func validate(name: String) throws {
            try self.validate(self.clusterSecurityGroupName, name: "clusterSecurityGroupName", parent: name, max: 2147483647)
            try self.validate(self.marker, name: "marker", parent: name, max: 2147483647)
            try self.tagKeys?.forEach {
                try validate($0, name: "tagKeys[]", parent: name, max: 2147483647)
            }
            try self.tagValues?.forEach {
                try validate($0, name: "tagValues[]", parent: name, max: 2147483647)
            }
        }

        private enum CodingKeys: String, CodingKey {
            case clusterSecurityGroupName = "ClusterSecurityGroupName"
            case marker = "Marker"
            case maxRecords = "MaxRecords"
            case tagKeys = "TagKeys"
            case tagValues = "TagValues"
        }
    }

    public struct DescribeClusterSnapshotsMessage: AWSEncodableShape {
        public struct _SortingEntitiesEncoding: ArrayCoderProperties { public static let member = "SnapshotSortingEntity" }
        public struct _TagKeysEncoding: ArrayCoderProperties { public static let member = "TagKey" }
        public struct _TagValuesEncoding: ArrayCoderProperties { public static let member = "TagValue" }

        /// A value that indicates whether to return snapshots only for an existing cluster. You can perform table-level restore only by using a snapshot of an existing cluster, that is, a cluster that has not been deleted. Values for this parameter work as follows:    If ClusterExists is set to true, ClusterIdentifier is required.   If ClusterExists is set to false and ClusterIdentifier isn't specified, all snapshots associated with deleted clusters (orphaned snapshots) are returned.    If ClusterExists is set to false and ClusterIdentifier is specified for a deleted cluster, snapshots associated with that cluster are returned.   If ClusterExists is set to false and ClusterIdentifier is specified for an existing cluster, no snapshots are returned.
        public let clusterExists: Bool?
        /// The identifier of the cluster which generated the requested snapshots.
        public let clusterIdentifier: String?
        /// A time value that requests only snapshots created at or before the specified time. The time value is specified in ISO 8601 format. For more information about ISO 8601, go to the ISO8601 Wikipedia page.  Example: 2012-07-16T18:00:00Z
        public let endTime: Date?
        /// An optional parameter that specifies the starting point to return a set of response records. When the results of a DescribeClusterSnapshots request exceed the value specified in MaxRecords, Amazon Web Services returns a value in the Marker field of the response. You can retrieve the next set of response records by providing the returned marker value in the Marker parameter and retrying the request.
        public let marker: String?
        /// The maximum number of response records to return in each call. If the number of remaining response records exceeds the specified MaxRecords value, a value is returned in a marker field of the response. You can retrieve the next set of records by retrying the command with the returned marker value.  Default: 100  Constraints: minimum 20, maximum 100.
        public let maxRecords: Int?
        /// The Amazon Web Services account used to create or copy the snapshot. Use this field to filter the results to snapshots owned by a particular account. To describe snapshots you own, either specify your Amazon Web Services account, or do not specify the parameter.
        public let ownerAccount: String?
        /// The Amazon Resource Name (ARN) of the snapshot associated with the message to describe cluster snapshots.
        public let snapshotArn: String?
        /// The snapshot identifier of the snapshot about which to return information.
        public let snapshotIdentifier: String?
        /// The type of snapshots for which you are requesting information. By default, snapshots of all types are returned. Valid Values: automated | manual
        public let snapshotType: String?
        @OptionalCustomCoding<ArrayCoder<_SortingEntitiesEncoding, SnapshotSortingEntity>>
        public var sortingEntities: [SnapshotSortingEntity]?
        /// A value that requests only snapshots created at or after the specified time. The time value is specified in ISO 8601 format. For more information about ISO 8601, go to the ISO8601 Wikipedia page.  Example: 2012-07-16T18:00:00Z
        public let startTime: Date?
        /// A tag key or keys for which you want to return all matching cluster snapshots that are associated with the specified key or keys. For example, suppose that you have snapshots that are tagged with keys called owner and environment. If you specify both of these tag keys in the request, Amazon Redshift returns a response with the snapshots that have either or both of these tag keys associated with them.
        @OptionalCustomCoding<ArrayCoder<_TagKeysEncoding, String>>
        public var tagKeys: [String]?
        /// A tag value or values for which you want to return all matching cluster snapshots that are associated with the specified tag value or values. For example, suppose that you have snapshots that are tagged with values called admin and test. If you specify both of these tag values in the request, Amazon Redshift returns a response with the snapshots that have either or both of these tag values associated with them.
        @OptionalCustomCoding<ArrayCoder<_TagValuesEncoding, String>>
        public var tagValues: [String]?

        @inlinable
        public init(clusterExists: Bool? = nil, clusterIdentifier: String? = nil, endTime: Date? = nil, marker: String? = nil, maxRecords: Int? = nil, ownerAccount: String? = nil, snapshotArn: String? = nil, snapshotIdentifier: String? = nil, snapshotType: String? = nil, sortingEntities: [SnapshotSortingEntity]? = nil, startTime: Date? = nil, tagKeys: [String]? = nil, tagValues: [String]? = nil) {
            self.clusterExists = clusterExists
            self.clusterIdentifier = clusterIdentifier
            self.endTime = endTime
            self.marker = marker
            self.maxRecords = maxRecords
            self.ownerAccount = ownerAccount
            self.snapshotArn = snapshotArn
            self.snapshotIdentifier = snapshotIdentifier
            self.snapshotType = snapshotType
            self.sortingEntities = sortingEntities
            self.startTime = startTime
            self.tagKeys = tagKeys
            self.tagValues = tagValues
        }

        public func validate(name: String) throws {
            try self.validate(self.clusterIdentifier, name: "clusterIdentifier", parent: name, max: 2147483647)
            try self.validate(self.marker, name: "marker", parent: name, max: 2147483647)
            try self.validate(self.ownerAccount, name: "ownerAccount", parent: name, max: 2147483647)
            try self.validate(self.snapshotArn, name: "snapshotArn", parent: name, max: 2147483647)
            try self.validate(self.snapshotIdentifier, name: "snapshotIdentifier", parent: name, max: 2147483647)
            try self.validate(self.snapshotType, name: "snapshotType", parent: name, max: 2147483647)
            try self.tagKeys?.forEach {
                try validate($0, name: "tagKeys[]", parent: name, max: 2147483647)
            }
            try self.tagValues?.forEach {
                try validate($0, name: "tagValues[]", parent: name, max: 2147483647)
            }
        }

        private enum CodingKeys: String, CodingKey {
            case clusterExists = "ClusterExists"
            case clusterIdentifier = "ClusterIdentifier"
            case endTime = "EndTime"
            case marker = "Marker"
            case maxRecords = "MaxRecords"
            case ownerAccount = "OwnerAccount"
            case snapshotArn = "SnapshotArn"
            case snapshotIdentifier = "SnapshotIdentifier"
            case snapshotType = "SnapshotType"
            case sortingEntities = "SortingEntities"
            case startTime = "StartTime"
            case tagKeys = "TagKeys"
            case tagValues = "TagValues"
        }
    }

    public struct DescribeClusterSubnetGroupsMessage: AWSEncodableShape {
        public struct _TagKeysEncoding: ArrayCoderProperties { public static let member = "TagKey" }
        public struct _TagValuesEncoding: ArrayCoderProperties { public static let member = "TagValue" }

        /// The name of the cluster subnet group for which information is requested.
        public let clusterSubnetGroupName: String?
        /// An optional parameter that specifies the starting point to return a set of response records. When the results of a DescribeClusterSubnetGroups request exceed the value specified in MaxRecords, Amazon Web Services returns a value in the Marker field of the response. You can retrieve the next set of response records by providing the returned marker value in the Marker parameter and retrying the request.
        public let marker: String?
        /// The maximum number of response records to return in each call. If the number of remaining response records exceeds the specified MaxRecords value, a value is returned in a marker field of the response. You can retrieve the next set of records by retrying the command with the returned marker value.  Default: 100  Constraints: minimum 20, maximum 100.
        public let maxRecords: Int?
        /// A tag key or keys for which you want to return all matching cluster subnet groups that are associated with the specified key or keys. For example, suppose that you have subnet groups that are tagged with keys called owner and environment. If you specify both of these tag keys in the request, Amazon Redshift returns a response with the subnet groups that have either or both of these tag keys associated with them.
        @OptionalCustomCoding<ArrayCoder<_TagKeysEncoding, String>>
        public var tagKeys: [String]?
        /// A tag value or values for which you want to return all matching cluster subnet groups that are associated with the specified tag value or values. For example, suppose that you have subnet groups that are tagged with values called admin and test. If you specify both of these tag values in the request, Amazon Redshift returns a response with the subnet groups that have either or both of these tag values associated with them.
        @OptionalCustomCoding<ArrayCoder<_TagValuesEncoding, String>>
        public var tagValues: [String]?

        @inlinable
        public init(clusterSubnetGroupName: String? = nil, marker: String? = nil, maxRecords: Int? = nil, tagKeys: [String]? = nil, tagValues: [String]? = nil) {
            self.clusterSubnetGroupName = clusterSubnetGroupName
            self.marker = marker
            self.maxRecords = maxRecords
            self.tagKeys = tagKeys
            self.tagValues = tagValues
        }

        public func validate(name: String) throws {
            try self.validate(self.clusterSubnetGroupName, name: "clusterSubnetGroupName", parent: name, max: 2147483647)
            try self.validate(self.marker, name: "marker", parent: name, max: 2147483647)
            try self.tagKeys?.forEach {
                try validate($0, name: "tagKeys[]", parent: name, max: 2147483647)
            }
            try self.tagValues?.forEach {
                try validate($0, name: "tagValues[]", parent: name, max: 2147483647)
            }
        }

        private enum CodingKeys: String, CodingKey {
            case clusterSubnetGroupName = "ClusterSubnetGroupName"
            case marker = "Marker"
            case maxRecords = "MaxRecords"
            case tagKeys = "TagKeys"
            case tagValues = "TagValues"
        }
    }

    public struct DescribeClusterTracksMessage: AWSEncodableShape {
        /// The name of the maintenance track.
        public let maintenanceTrackName: String?
        /// An optional parameter that specifies the starting point to return a set of response records. When the results of a DescribeClusterTracks request exceed the value specified in MaxRecords, Amazon Redshift returns a value in the Marker field of the response. You can retrieve the next set of response records by providing the returned marker value in the Marker parameter and retrying the request.
        public let marker: String?
        /// An integer value for the maximum number of maintenance tracks to return.
        public let maxRecords: Int?

        @inlinable
        public init(maintenanceTrackName: String? = nil, marker: String? = nil, maxRecords: Int? = nil) {
            self.maintenanceTrackName = maintenanceTrackName
            self.marker = marker
            self.maxRecords = maxRecords
        }

        public func validate(name: String) throws {
            try self.validate(self.maintenanceTrackName, name: "maintenanceTrackName", parent: name, max: 2147483647)
            try self.validate(self.marker, name: "marker", parent: name, max: 2147483647)
        }

        private enum CodingKeys: String, CodingKey {
            case maintenanceTrackName = "MaintenanceTrackName"
            case marker = "Marker"
            case maxRecords = "MaxRecords"
        }
    }

    public struct DescribeClusterVersionsMessage: AWSEncodableShape {
        /// The name of a specific cluster parameter group family to return details for. Constraints:   Must be 1 to 255 alphanumeric characters   First character must be a letter   Cannot end with a hyphen or contain two consecutive hyphens
        public let clusterParameterGroupFamily: String?
        /// The specific cluster version to return. Example: 1.0
        public let clusterVersion: String?
        /// An optional parameter that specifies the starting point to return a set of response records. When the results of a DescribeClusterVersions request exceed the value specified in MaxRecords, Amazon Web Services returns a value in the Marker field of the response. You can retrieve the next set of response records by providing the returned marker value in the Marker parameter and retrying the request.
        public let marker: String?
        /// The maximum number of response records to return in each call. If the number of remaining response records exceeds the specified MaxRecords value, a value is returned in a marker field of the response. You can retrieve the next set of records by retrying the command with the returned marker value.  Default: 100  Constraints: minimum 20, maximum 100.
        public let maxRecords: Int?

        @inlinable
        public init(clusterParameterGroupFamily: String? = nil, clusterVersion: String? = nil, marker: String? = nil, maxRecords: Int? = nil) {
            self.clusterParameterGroupFamily = clusterParameterGroupFamily
            self.clusterVersion = clusterVersion
            self.marker = marker
            self.maxRecords = maxRecords
        }

        public func validate(name: String) throws {
            try self.validate(self.clusterParameterGroupFamily, name: "clusterParameterGroupFamily", parent: name, max: 2147483647)
            try self.validate(self.clusterVersion, name: "clusterVersion", parent: name, max: 2147483647)
            try self.validate(self.marker, name: "marker", parent: name, max: 2147483647)
        }

        private enum CodingKeys: String, CodingKey {
            case clusterParameterGroupFamily = "ClusterParameterGroupFamily"
            case clusterVersion = "ClusterVersion"
            case marker = "Marker"
            case maxRecords = "MaxRecords"
        }
    }

    public struct DescribeClustersMessage: AWSEncodableShape {
        public struct _TagKeysEncoding: ArrayCoderProperties { public static let member = "TagKey" }
        public struct _TagValuesEncoding: ArrayCoderProperties { public static let member = "TagValue" }

        /// The unique identifier of a cluster whose properties you are requesting. This parameter is case sensitive. The default is that all clusters defined for an account are returned.
        public let clusterIdentifier: String?
        /// An optional parameter that specifies the starting point to return a set of response records. When the results of a DescribeClusters request exceed the value specified in MaxRecords, Amazon Web Services returns a value in the Marker field of the response. You can retrieve the next set of response records by providing the returned marker value in the Marker parameter and retrying the request.  Constraints: You can specify either the ClusterIdentifier parameter or the Marker parameter, but not both.
        public let marker: String?
        /// The maximum number of response records to return in each call. If the number of remaining response records exceeds the specified MaxRecords value, a value is returned in a marker field of the response. You can retrieve the next set of records by retrying the command with the returned marker value.  Default: 100  Constraints: minimum 20, maximum 100.
        public let maxRecords: Int?
        /// A tag key or keys for which you want to return all matching clusters that are associated with the specified key or keys. For example, suppose that you have clusters that are tagged with keys called owner and environment. If you specify both of these tag keys in the request, Amazon Redshift returns a response with the clusters that have either or both of these tag keys associated with them.
        @OptionalCustomCoding<ArrayCoder<_TagKeysEncoding, String>>
        public var tagKeys: [String]?
        /// A tag value or values for which you want to return all matching clusters that are associated with the specified tag value or values. For example, suppose that you have clusters that are tagged with values called admin and test. If you specify both of these tag values in the request, Amazon Redshift returns a response with the clusters that have either or both of these tag values associated with them.
        @OptionalCustomCoding<ArrayCoder<_TagValuesEncoding, String>>
        public var tagValues: [String]?

        @inlinable
        public init(clusterIdentifier: String? = nil, marker: String? = nil, maxRecords: Int? = nil, tagKeys: [String]? = nil, tagValues: [String]? = nil) {
            self.clusterIdentifier = clusterIdentifier
            self.marker = marker
            self.maxRecords = maxRecords
            self.tagKeys = tagKeys
            self.tagValues = tagValues
        }

        public func validate(name: String) throws {
            try self.validate(self.clusterIdentifier, name: "clusterIdentifier", parent: name, max: 2147483647)
            try self.validate(self.marker, name: "marker", parent: name, max: 2147483647)
            try self.tagKeys?.forEach {
                try validate($0, name: "tagKeys[]", parent: name, max: 2147483647)
            }
            try self.tagValues?.forEach {
                try validate($0, name: "tagValues[]", parent: name, max: 2147483647)
            }
        }

        private enum CodingKeys: String, CodingKey {
            case clusterIdentifier = "ClusterIdentifier"
            case marker = "Marker"
            case maxRecords = "MaxRecords"
            case tagKeys = "TagKeys"
            case tagValues = "TagValues"
        }
    }

    public struct DescribeCustomDomainAssociationsMessage: AWSEncodableShape {
        /// The certificate Amazon Resource Name (ARN) for the custom domain association.
        public let customDomainCertificateArn: String?
        /// The custom domain name for the custom domain association.
        public let customDomainName: String?
        /// The marker for the custom domain association.
        public let marker: String?
        /// The maximum records setting for the associated custom domain.
        public let maxRecords: Int?

        @inlinable
        public init(customDomainCertificateArn: String? = nil, customDomainName: String? = nil, marker: String? = nil, maxRecords: Int? = nil) {
            self.customDomainCertificateArn = customDomainCertificateArn
            self.customDomainName = customDomainName
            self.marker = marker
            self.maxRecords = maxRecords
        }

        public func validate(name: String) throws {
            try self.validate(self.customDomainCertificateArn, name: "customDomainCertificateArn", parent: name, max: 2048)
            try self.validate(self.customDomainCertificateArn, name: "customDomainCertificateArn", parent: name, min: 20)
            try self.validate(self.customDomainCertificateArn, name: "customDomainCertificateArn", parent: name, pattern: "^arn:[\\w+=/,.@-]+:acm:[\\w+=/,.@-]*:[0-9]+:[\\w+=,.@-]+(/[\\w+=,.@-]+)*$")
            try self.validate(self.customDomainName, name: "customDomainName", parent: name, max: 253)
            try self.validate(self.customDomainName, name: "customDomainName", parent: name, min: 1)
            try self.validate(self.customDomainName, name: "customDomainName", parent: name, pattern: "^(((?!-)[A-Za-z0-9-]{0,62}[A-Za-z0-9])\\.)+((?!-)[A-Za-z0-9-]{1,62}[A-Za-z0-9])$")
            try self.validate(self.marker, name: "marker", parent: name, max: 2147483647)
        }

        private enum CodingKeys: String, CodingKey {
            case customDomainCertificateArn = "CustomDomainCertificateArn"
            case customDomainName = "CustomDomainName"
            case marker = "Marker"
            case maxRecords = "MaxRecords"
        }
    }

    public struct DescribeDataSharesForConsumerMessage: AWSEncodableShape {
        /// The Amazon Resource Name (ARN) of the consumer namespace that returns in the list of datashares.
        public let consumerArn: String?
        /// An optional parameter that specifies the starting point to return a set of response records. When the results of a DescribeDataSharesForConsumer request exceed the value specified in MaxRecords, Amazon Web Services returns a value in the Marker field of the response. You can retrieve the next set of response records by providing the returned marker value in the Marker parameter and retrying the request.
        public let marker: String?
        /// The maximum number of response records to return in each call. If the number of remaining response records exceeds the specified MaxRecords value, a value is returned in a marker field of the response. You can retrieve the next set of records by retrying the command with the returned marker value.
        public let maxRecords: Int?
        /// An identifier giving the status of a datashare in the consumer cluster. If this field is specified, Amazon Redshift returns the list of datashares that have the specified status.
        public let status: DataShareStatusForConsumer?

        @inlinable
        public init(consumerArn: String? = nil, marker: String? = nil, maxRecords: Int? = nil, status: DataShareStatusForConsumer? = nil) {
            self.consumerArn = consumerArn
            self.marker = marker
            self.maxRecords = maxRecords
            self.status = status
        }

        public func validate(name: String) throws {
            try self.validate(self.consumerArn, name: "consumerArn", parent: name, max: 2147483647)
            try self.validate(self.marker, name: "marker", parent: name, max: 2147483647)
        }

        private enum CodingKeys: String, CodingKey {
            case consumerArn = "ConsumerArn"
            case marker = "Marker"
            case maxRecords = "MaxRecords"
            case status = "Status"
        }
    }

    public struct DescribeDataSharesForConsumerResult: AWSDecodableShape {
        /// Shows the results of datashares available for consumers.
        @OptionalCustomCoding<StandardArrayCoder<DataShare>>
        public var dataShares: [DataShare]?
        /// An optional parameter that specifies the starting point to return a set of response records. When the results of a DescribeDataSharesForConsumer request exceed the value specified in MaxRecords, Amazon Web Services returns a value in the Marker field of the response. You can retrieve the next set of response records by providing the returned marker value in the Marker parameter and retrying the request.
        public let marker: String?

        @inlinable
        public init(dataShares: [DataShare]? = nil, marker: String? = nil) {
            self.dataShares = dataShares
            self.marker = marker
        }

        private enum CodingKeys: String, CodingKey {
            case dataShares = "DataShares"
            case marker = "Marker"
        }
    }

    public struct DescribeDataSharesForProducerMessage: AWSEncodableShape {
        /// An optional parameter that specifies the starting point to return a set of response records. When the results of a DescribeDataSharesForProducer request exceed the value specified in MaxRecords, Amazon Web Services returns a value in the Marker field of the response. You can retrieve the next set of response records by providing the returned marker value in the Marker parameter and retrying the request.
        public let marker: String?
        /// The maximum number of response records to return in each call. If the number of remaining response records exceeds the specified MaxRecords value, a value is returned in a marker field of the response. You can retrieve the next set of records by retrying the command with the returned marker value.
        public let maxRecords: Int?
        /// The Amazon Resource Name (ARN) of the producer namespace that returns in the list of datashares.
        public let producerArn: String?
        /// An identifier giving the status of a datashare in the producer. If this field is specified, Amazon Redshift returns the list of datashares that have the specified status.
        public let status: DataShareStatusForProducer?

        @inlinable
        public init(marker: String? = nil, maxRecords: Int? = nil, producerArn: String? = nil, status: DataShareStatusForProducer? = nil) {
            self.marker = marker
            self.maxRecords = maxRecords
            self.producerArn = producerArn
            self.status = status
        }

        public func validate(name: String) throws {
            try self.validate(self.marker, name: "marker", parent: name, max: 2147483647)
            try self.validate(self.producerArn, name: "producerArn", parent: name, max: 2147483647)
        }

        private enum CodingKeys: String, CodingKey {
            case marker = "Marker"
            case maxRecords = "MaxRecords"
            case producerArn = "ProducerArn"
            case status = "Status"
        }
    }

    public struct DescribeDataSharesForProducerResult: AWSDecodableShape {
        /// Shows the results of datashares available for producers.
        @OptionalCustomCoding<StandardArrayCoder<DataShare>>
        public var dataShares: [DataShare]?
        /// An optional parameter that specifies the starting point to return a set of response records. When the results of a DescribeDataSharesForProducer request exceed the value specified in MaxRecords, Amazon Web Services returns a value in the Marker field of the response. You can retrieve the next set of response records by providing the returned marker value in the Marker parameter and retrying the request.
        public let marker: String?

        @inlinable
        public init(dataShares: [DataShare]? = nil, marker: String? = nil) {
            self.dataShares = dataShares
            self.marker = marker
        }

        private enum CodingKeys: String, CodingKey {
            case dataShares = "DataShares"
            case marker = "Marker"
        }
    }

    public struct DescribeDataSharesMessage: AWSEncodableShape {
        /// The Amazon resource name (ARN) of the datashare to describe details of.
        public let dataShareArn: String?
        /// An optional parameter that specifies the starting point to return a set of response records. When the results of a DescribeDataShares request exceed the value specified in MaxRecords, Amazon Web Services returns a value in the Marker field of the response. You can retrieve the next set of response records by providing the returned marker value in the Marker parameter and retrying the request.
        public let marker: String?
        /// The maximum number of response records to return in each call. If the number of remaining response records exceeds the specified MaxRecords value, a value is returned in a marker field of the response. You can retrieve the next set of records by retrying the command with the returned marker value.
        public let maxRecords: Int?

        @inlinable
        public init(dataShareArn: String? = nil, marker: String? = nil, maxRecords: Int? = nil) {
            self.dataShareArn = dataShareArn
            self.marker = marker
            self.maxRecords = maxRecords
        }

        public func validate(name: String) throws {
            try self.validate(self.dataShareArn, name: "dataShareArn", parent: name, max: 2147483647)
            try self.validate(self.marker, name: "marker", parent: name, max: 2147483647)
        }

        private enum CodingKeys: String, CodingKey {
            case dataShareArn = "DataShareArn"
            case marker = "Marker"
            case maxRecords = "MaxRecords"
        }
    }

    public struct DescribeDataSharesResult: AWSDecodableShape {
        /// The results returned from describing datashares.
        @OptionalCustomCoding<StandardArrayCoder<DataShare>>
        public var dataShares: [DataShare]?
        /// An optional parameter that specifies the starting point to return a set of response records. When the results of a DescribeDataShares request exceed the value specified in MaxRecords, Amazon Web Services returns a value in the Marker field of the response. You can retrieve the next set of response records by providing the returned marker value in the Marker parameter and retrying the request.
        public let marker: String?

        @inlinable
        public init(dataShares: [DataShare]? = nil, marker: String? = nil) {
            self.dataShares = dataShares
            self.marker = marker
        }

        private enum CodingKeys: String, CodingKey {
            case dataShares = "DataShares"
            case marker = "Marker"
        }
    }

    public struct DescribeDefaultClusterParametersMessage: AWSEncodableShape {
        /// An optional parameter that specifies the starting point to return a set of response records. When the results of a DescribeDefaultClusterParameters request exceed the value specified in MaxRecords, Amazon Web Services returns a value in the Marker field of the response. You can retrieve the next set of response records by providing the returned marker value in the Marker parameter and retrying the request.
        public let marker: String?
        /// The maximum number of response records to return in each call. If the number of remaining response records exceeds the specified MaxRecords value, a value is returned in a marker field of the response. You can retrieve the next set of records by retrying the command with the returned marker value.  Default: 100  Constraints: minimum 20, maximum 100.
        public let maxRecords: Int?
        /// The name of the cluster parameter group family.
        public let parameterGroupFamily: String?

        @inlinable
        public init(marker: String? = nil, maxRecords: Int? = nil, parameterGroupFamily: String? = nil) {
            self.marker = marker
            self.maxRecords = maxRecords
            self.parameterGroupFamily = parameterGroupFamily
        }

        public func validate(name: String) throws {
            try self.validate(self.marker, name: "marker", parent: name, max: 2147483647)
            try self.validate(self.parameterGroupFamily, name: "parameterGroupFamily", parent: name, max: 2147483647)
        }

        private enum CodingKeys: String, CodingKey {
            case marker = "Marker"
            case maxRecords = "MaxRecords"
            case parameterGroupFamily = "ParameterGroupFamily"
        }
    }

    public struct DescribeDefaultClusterParametersResult: AWSDecodableShape {
        public let defaultClusterParameters: DefaultClusterParameters?

        @inlinable
        public init(defaultClusterParameters: DefaultClusterParameters? = nil) {
            self.defaultClusterParameters = defaultClusterParameters
        }

        private enum CodingKeys: String, CodingKey {
            case defaultClusterParameters = "DefaultClusterParameters"
        }
    }

    public struct DescribeEndpointAccessMessage: AWSEncodableShape {
        /// The cluster identifier associated with the described endpoint.
        public let clusterIdentifier: String?
        /// The name of the endpoint to be described.
        public let endpointName: String?
        /// An optional pagination token provided by a previous DescribeEndpointAccess request. If this parameter is specified, the response includes only records beyond the marker, up to the value specified by the MaxRecords parameter.
        public let marker: String?
        /// The maximum number of records to include in the response. If more records exist than the specified MaxRecords value, a pagination token called a Marker is included in the response so that the remaining results can be retrieved.
        public let maxRecords: Int?
        /// The Amazon Web Services account ID of the owner of the cluster.
        public let resourceOwner: String?
        /// The virtual private cloud (VPC) identifier with access to the cluster.
        public let vpcId: String?

        @inlinable
        public init(clusterIdentifier: String? = nil, endpointName: String? = nil, marker: String? = nil, maxRecords: Int? = nil, resourceOwner: String? = nil, vpcId: String? = nil) {
            self.clusterIdentifier = clusterIdentifier
            self.endpointName = endpointName
            self.marker = marker
            self.maxRecords = maxRecords
            self.resourceOwner = resourceOwner
            self.vpcId = vpcId
        }

        public func validate(name: String) throws {
            try self.validate(self.clusterIdentifier, name: "clusterIdentifier", parent: name, max: 2147483647)
            try self.validate(self.endpointName, name: "endpointName", parent: name, max: 2147483647)
            try self.validate(self.marker, name: "marker", parent: name, max: 2147483647)
            try self.validate(self.resourceOwner, name: "resourceOwner", parent: name, max: 2147483647)
            try self.validate(self.vpcId, name: "vpcId", parent: name, max: 2147483647)
        }

        private enum CodingKeys: String, CodingKey {
            case clusterIdentifier = "ClusterIdentifier"
            case endpointName = "EndpointName"
            case marker = "Marker"
            case maxRecords = "MaxRecords"
            case resourceOwner = "ResourceOwner"
            case vpcId = "VpcId"
        }
    }

    public struct DescribeEndpointAuthorizationMessage: AWSEncodableShape {
        /// The Amazon Web Services account ID of either the cluster owner (grantor) or grantee.  If Grantee parameter is true, then the Account value is of the grantor.
        public let account: String?
        /// The cluster identifier of the cluster to access.
        public let clusterIdentifier: String?
        /// Indicates whether to check authorization from a grantor or grantee point of view.  If true, Amazon Redshift returns endpoint authorizations that you've been granted. If false (default), checks authorization from a grantor point of view.
        public let grantee: Bool?
        /// An optional pagination token provided by a previous DescribeEndpointAuthorization request. If this parameter is specified, the response includes only records beyond the marker, up to the value specified by the MaxRecords parameter.
        public let marker: String?
        /// The maximum number of records to include in the response. If more records exist than the specified MaxRecords value, a pagination token called a Marker is included in the response so that the remaining results can be retrieved.
        public let maxRecords: Int?

        @inlinable
        public init(account: String? = nil, clusterIdentifier: String? = nil, grantee: Bool? = nil, marker: String? = nil, maxRecords: Int? = nil) {
            self.account = account
            self.clusterIdentifier = clusterIdentifier
            self.grantee = grantee
            self.marker = marker
            self.maxRecords = maxRecords
        }

        public func validate(name: String) throws {
            try self.validate(self.account, name: "account", parent: name, max: 2147483647)
            try self.validate(self.clusterIdentifier, name: "clusterIdentifier", parent: name, max: 2147483647)
            try self.validate(self.marker, name: "marker", parent: name, max: 2147483647)
        }

        private enum CodingKeys: String, CodingKey {
            case account = "Account"
            case clusterIdentifier = "ClusterIdentifier"
            case grantee = "Grantee"
            case marker = "Marker"
            case maxRecords = "MaxRecords"
        }
    }

    public struct DescribeEventCategoriesMessage: AWSEncodableShape {
        /// The source type, such as cluster or parameter group, to which the described event categories apply. Valid values: cluster, cluster-snapshot, cluster-parameter-group, cluster-security-group, and scheduled-action.
        public let sourceType: String?

        @inlinable
        public init(sourceType: String? = nil) {
            self.sourceType = sourceType
        }

        public func validate(name: String) throws {
            try self.validate(self.sourceType, name: "sourceType", parent: name, max: 2147483647)
        }

        private enum CodingKeys: String, CodingKey {
            case sourceType = "SourceType"
        }
    }

    public struct DescribeEventSubscriptionsMessage: AWSEncodableShape {
        public struct _TagKeysEncoding: ArrayCoderProperties { public static let member = "TagKey" }
        public struct _TagValuesEncoding: ArrayCoderProperties { public static let member = "TagValue" }

        /// An optional parameter that specifies the starting point to return a set of response records. When the results of a DescribeEventSubscriptions request exceed the value specified in MaxRecords, Amazon Web Services returns a value in the Marker field of the response. You can retrieve the next set of response records by providing the returned marker value in the Marker parameter and retrying the request.
        public let marker: String?
        /// The maximum number of response records to return in each call. If the number of remaining response records exceeds the specified MaxRecords value, a value is returned in a marker field of the response. You can retrieve the next set of records by retrying the command with the returned marker value.  Default: 100  Constraints: minimum 20, maximum 100.
        public let maxRecords: Int?
        /// The name of the Amazon Redshift event notification subscription to be described.
        public let subscriptionName: String?
        /// A tag key or keys for which you want to return all matching event notification subscriptions that are associated with the specified key or keys. For example, suppose that you have subscriptions that are tagged with keys called owner and environment. If you specify both of these tag keys in the request, Amazon Redshift returns a response with the subscriptions that have either or both of these tag keys associated with them.
        @OptionalCustomCoding<ArrayCoder<_TagKeysEncoding, String>>
        public var tagKeys: [String]?
        /// A tag value or values for which you want to return all matching event notification subscriptions that are associated with the specified tag value or values. For example, suppose that you have subscriptions that are tagged with values called admin and test. If you specify both of these tag values in the request, Amazon Redshift returns a response with the subscriptions that have either or both of these tag values associated with them.
        @OptionalCustomCoding<ArrayCoder<_TagValuesEncoding, String>>
        public var tagValues: [String]?

        @inlinable
        public init(marker: String? = nil, maxRecords: Int? = nil, subscriptionName: String? = nil, tagKeys: [String]? = nil, tagValues: [String]? = nil) {
            self.marker = marker
            self.maxRecords = maxRecords
            self.subscriptionName = subscriptionName
            self.tagKeys = tagKeys
            self.tagValues = tagValues
        }

        public func validate(name: String) throws {
            try self.validate(self.marker, name: "marker", parent: name, max: 2147483647)
            try self.validate(self.subscriptionName, name: "subscriptionName", parent: name, max: 2147483647)
            try self.tagKeys?.forEach {
                try validate($0, name: "tagKeys[]", parent: name, max: 2147483647)
            }
            try self.tagValues?.forEach {
                try validate($0, name: "tagValues[]", parent: name, max: 2147483647)
            }
        }

        private enum CodingKeys: String, CodingKey {
            case marker = "Marker"
            case maxRecords = "MaxRecords"
            case subscriptionName = "SubscriptionName"
            case tagKeys = "TagKeys"
            case tagValues = "TagValues"
        }
    }

    public struct DescribeEventsMessage: AWSEncodableShape {
        /// The number of minutes prior to the time of the request for which to retrieve events. For example, if the request is sent at 18:00 and you specify a duration of 60, then only events which have occurred after 17:00 will be returned. Default: 60
        public let duration: Int?
        /// The end of the time interval for which to retrieve events, specified in ISO 8601 format. For more information about ISO 8601, go to the ISO8601 Wikipedia page.  Example: 2009-07-08T18:00Z
        public let endTime: Date?
        /// An optional parameter that specifies the starting point to return a set of response records. When the results of a DescribeEvents request exceed the value specified in MaxRecords, Amazon Web Services returns a value in the Marker field of the response. You can retrieve the next set of response records by providing the returned marker value in the Marker parameter and retrying the request.
        public let marker: String?
        /// The maximum number of response records to return in each call. If the number of remaining response records exceeds the specified MaxRecords value, a value is returned in a marker field of the response. You can retrieve the next set of records by retrying the command with the returned marker value.  Default: 100  Constraints: minimum 20, maximum 100.
        public let maxRecords: Int?
        /// The identifier of the event source for which events will be returned. If this parameter is not specified, then all sources are included in the response. Constraints: If SourceIdentifier is supplied, SourceType must also be provided.   Specify a cluster identifier when SourceType is cluster.   Specify a cluster security group name when SourceType is cluster-security-group.   Specify a cluster parameter group name when SourceType is cluster-parameter-group.   Specify a cluster snapshot identifier when SourceType is cluster-snapshot.
        public let sourceIdentifier: String?
        /// The event source to retrieve events for. If no value is specified, all events are returned. Constraints: If SourceType is supplied, SourceIdentifier must also be provided.   Specify cluster when SourceIdentifier is a cluster identifier.   Specify cluster-security-group when SourceIdentifier is a cluster security group name.   Specify cluster-parameter-group when SourceIdentifier is a cluster parameter group name.   Specify cluster-snapshot when SourceIdentifier is a cluster snapshot identifier.
        public let sourceType: SourceType?
        /// The beginning of the time interval to retrieve events for, specified in ISO 8601 format. For more information about ISO 8601, go to the ISO8601 Wikipedia page.  Example: 2009-07-08T18:00Z
        public let startTime: Date?

        @inlinable
        public init(duration: Int? = nil, endTime: Date? = nil, marker: String? = nil, maxRecords: Int? = nil, sourceIdentifier: String? = nil, sourceType: SourceType? = nil, startTime: Date? = nil) {
            self.duration = duration
            self.endTime = endTime
            self.marker = marker
            self.maxRecords = maxRecords
            self.sourceIdentifier = sourceIdentifier
            self.sourceType = sourceType
            self.startTime = startTime
        }

        public func validate(name: String) throws {
            try self.validate(self.marker, name: "marker", parent: name, max: 2147483647)
            try self.validate(self.sourceIdentifier, name: "sourceIdentifier", parent: name, max: 2147483647)
        }

        private enum CodingKeys: String, CodingKey {
            case duration = "Duration"
            case endTime = "EndTime"
            case marker = "Marker"
            case maxRecords = "MaxRecords"
            case sourceIdentifier = "SourceIdentifier"
            case sourceType = "SourceType"
            case startTime = "StartTime"
        }
    }

    public struct DescribeHsmClientCertificatesMessage: AWSEncodableShape {
        public struct _TagKeysEncoding: ArrayCoderProperties { public static let member = "TagKey" }
        public struct _TagValuesEncoding: ArrayCoderProperties { public static let member = "TagValue" }

        /// The identifier of a specific HSM client certificate for which you want information. If no identifier is specified, information is returned for all HSM client certificates owned by your Amazon Web Services account.
        public let hsmClientCertificateIdentifier: String?
        /// An optional parameter that specifies the starting point to return a set of response records. When the results of a DescribeHsmClientCertificates request exceed the value specified in MaxRecords, Amazon Web Services returns a value in the Marker field of the response. You can retrieve the next set of response records by providing the returned marker value in the Marker parameter and retrying the request.
        public let marker: String?
        /// The maximum number of response records to return in each call. If the number of remaining response records exceeds the specified MaxRecords value, a value is returned in a marker field of the response. You can retrieve the next set of records by retrying the command with the returned marker value.  Default: 100  Constraints: minimum 20, maximum 100.
        public let maxRecords: Int?
        /// A tag key or keys for which you want to return all matching HSM client certificates that are associated with the specified key or keys. For example, suppose that you have HSM client certificates that are tagged with keys called owner and environment. If you specify both of these tag keys in the request, Amazon Redshift returns a response with the HSM client certificates that have either or both of these tag keys associated with them.
        @OptionalCustomCoding<ArrayCoder<_TagKeysEncoding, String>>
        public var tagKeys: [String]?
        /// A tag value or values for which you want to return all matching HSM client certificates that are associated with the specified tag value or values. For example, suppose that you have HSM client certificates that are tagged with values called admin and test. If you specify both of these tag values in the request, Amazon Redshift returns a response with the HSM client certificates that have either or both of these tag values associated with them.
        @OptionalCustomCoding<ArrayCoder<_TagValuesEncoding, String>>
        public var tagValues: [String]?

        @inlinable
        public init(hsmClientCertificateIdentifier: String? = nil, marker: String? = nil, maxRecords: Int? = nil, tagKeys: [String]? = nil, tagValues: [String]? = nil) {
            self.hsmClientCertificateIdentifier = hsmClientCertificateIdentifier
            self.marker = marker
            self.maxRecords = maxRecords
            self.tagKeys = tagKeys
            self.tagValues = tagValues
        }

        public func validate(name: String) throws {
            try self.validate(self.hsmClientCertificateIdentifier, name: "hsmClientCertificateIdentifier", parent: name, max: 2147483647)
            try self.validate(self.marker, name: "marker", parent: name, max: 2147483647)
            try self.tagKeys?.forEach {
                try validate($0, name: "tagKeys[]", parent: name, max: 2147483647)
            }
            try self.tagValues?.forEach {
                try validate($0, name: "tagValues[]", parent: name, max: 2147483647)
            }
        }

        private enum CodingKeys: String, CodingKey {
            case hsmClientCertificateIdentifier = "HsmClientCertificateIdentifier"
            case marker = "Marker"
            case maxRecords = "MaxRecords"
            case tagKeys = "TagKeys"
            case tagValues = "TagValues"
        }
    }

    public struct DescribeHsmConfigurationsMessage: AWSEncodableShape {
        public struct _TagKeysEncoding: ArrayCoderProperties { public static let member = "TagKey" }
        public struct _TagValuesEncoding: ArrayCoderProperties { public static let member = "TagValue" }

        /// The identifier of a specific Amazon Redshift HSM configuration to be described. If no identifier is specified, information is returned for all HSM configurations owned by your Amazon Web Services account.
        public let hsmConfigurationIdentifier: String?
        /// An optional parameter that specifies the starting point to return a set of response records. When the results of a DescribeHsmConfigurations request exceed the value specified in MaxRecords, Amazon Web Services returns a value in the Marker field of the response. You can retrieve the next set of response records by providing the returned marker value in the Marker parameter and retrying the request.
        public let marker: String?
        /// The maximum number of response records to return in each call. If the number of remaining response records exceeds the specified MaxRecords value, a value is returned in a marker field of the response. You can retrieve the next set of records by retrying the command with the returned marker value.  Default: 100  Constraints: minimum 20, maximum 100.
        public let maxRecords: Int?
        /// A tag key or keys for which you want to return all matching HSM configurations that are associated with the specified key or keys. For example, suppose that you have HSM configurations that are tagged with keys called owner and environment. If you specify both of these tag keys in the request, Amazon Redshift returns a response with the HSM configurations that have either or both of these tag keys associated with them.
        @OptionalCustomCoding<ArrayCoder<_TagKeysEncoding, String>>
        public var tagKeys: [String]?
        /// A tag value or values for which you want to return all matching HSM configurations that are associated with the specified tag value or values. For example, suppose that you have HSM configurations that are tagged with values called admin and test. If you specify both of these tag values in the request, Amazon Redshift returns a response with the HSM configurations that have either or both of these tag values associated with them.
        @OptionalCustomCoding<ArrayCoder<_TagValuesEncoding, String>>
        public var tagValues: [String]?

        @inlinable
        public init(hsmConfigurationIdentifier: String? = nil, marker: String? = nil, maxRecords: Int? = nil, tagKeys: [String]? = nil, tagValues: [String]? = nil) {
            self.hsmConfigurationIdentifier = hsmConfigurationIdentifier
            self.marker = marker
            self.maxRecords = maxRecords
            self.tagKeys = tagKeys
            self.tagValues = tagValues
        }

        public func validate(name: String) throws {
            try self.validate(self.hsmConfigurationIdentifier, name: "hsmConfigurationIdentifier", parent: name, max: 2147483647)
            try self.validate(self.marker, name: "marker", parent: name, max: 2147483647)
            try self.tagKeys?.forEach {
                try validate($0, name: "tagKeys[]", parent: name, max: 2147483647)
            }
            try self.tagValues?.forEach {
                try validate($0, name: "tagValues[]", parent: name, max: 2147483647)
            }
        }

        private enum CodingKeys: String, CodingKey {
            case hsmConfigurationIdentifier = "HsmConfigurationIdentifier"
            case marker = "Marker"
            case maxRecords = "MaxRecords"
            case tagKeys = "TagKeys"
            case tagValues = "TagValues"
        }
    }

    public struct DescribeInboundIntegrationsMessage: AWSEncodableShape {
        /// The Amazon Resource Name (ARN) of the inbound integration.
        public let integrationArn: String?
        /// An optional parameter that specifies the starting point to return a set of response records. When the results of a DescribeInboundIntegrations request exceed the value specified in MaxRecords, Amazon Web Services returns a value in the Marker field of the response. You can retrieve the next set of response records by providing the returned marker value in the Marker parameter and retrying the request.
        public let marker: String?
        /// The maximum number of response records to return in each call. If the number of remaining response records exceeds the specified MaxRecords value, a value is returned in a marker field of the response. You can retrieve the next set of records by retrying the command with the returned marker value.  Default: 100  Constraints: minimum 20, maximum 100.
        public let maxRecords: Int?
        /// The Amazon Resource Name (ARN) of the target of an inbound integration.
        public let targetArn: String?

        @inlinable
        public init(integrationArn: String? = nil, marker: String? = nil, maxRecords: Int? = nil, targetArn: String? = nil) {
            self.integrationArn = integrationArn
            self.marker = marker
            self.maxRecords = maxRecords
            self.targetArn = targetArn
        }

        public func validate(name: String) throws {
            try self.validate(self.integrationArn, name: "integrationArn", parent: name, max: 255)
            try self.validate(self.integrationArn, name: "integrationArn", parent: name, min: 1)
            try self.validate(self.integrationArn, name: "integrationArn", parent: name, pattern: "^arn:aws[a-z\\-]*:.+:[a-z0-9\\-]*:[0-9]*:integration:[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$")
            try self.validate(self.marker, name: "marker", parent: name, max: 2147483647)
            try self.validate(self.targetArn, name: "targetArn", parent: name, max: 2048)
            try self.validate(self.targetArn, name: "targetArn", parent: name, min: 20)
            try self.validate(self.targetArn, name: "targetArn", parent: name, pattern: "^arn:aws[a-z\\-]*:redshift(-serverless)?:[a-z0-9\\-]+:[0-9]{12}:(namespace\\/|namespace:)[a-z0-9\\-]+$")
        }

        private enum CodingKeys: String, CodingKey {
            case integrationArn = "IntegrationArn"
            case marker = "Marker"
            case maxRecords = "MaxRecords"
            case targetArn = "TargetArn"
        }
    }

    public struct DescribeIntegrationsFilter: AWSEncodableShape {
        public struct _ValuesEncoding: ArrayCoderProperties { public static let member = "Value" }

        /// Specifies the type of integration filter.
        public let name: DescribeIntegrationsFilterName?
        /// Specifies the values to filter on.
        @OptionalCustomCoding<ArrayCoder<_ValuesEncoding, String>>
        public var values: [String]?

        @inlinable
        public init(name: DescribeIntegrationsFilterName? = nil, values: [String]? = nil) {
            self.name = name
            self.values = values
        }

        public func validate(name: String) throws {
            try self.values?.forEach {
                try validate($0, name: "values[]", parent: name, max: 2147483647)
            }
        }

        private enum CodingKeys: String, CodingKey {
            case name = "Name"
            case values = "Values"
        }
    }

    public struct DescribeIntegrationsMessage: AWSEncodableShape {
        public struct _FiltersEncoding: ArrayCoderProperties { public static let member = "DescribeIntegrationsFilter" }

        /// A filter that specifies one or more resources to return.
        @OptionalCustomCoding<ArrayCoder<_FiltersEncoding, DescribeIntegrationsFilter>>
        public var filters: [DescribeIntegrationsFilter]?
        /// The unique identifier of the integration.
        public let integrationArn: String?
        /// An optional pagination token provided by a previous DescribeIntegrations request. If this parameter is specified, the response includes only records beyond the marker, up to the value specified by MaxRecords.
        public let marker: String?
        /// The maximum number of response records to return in each call. If the number of remaining response records exceeds the specified MaxRecords value, a value is returned in a marker field of the response. You can retrieve the next set of records by retrying the command with the returned marker value.  Default: 100  Constraints: minimum 20, maximum 100.
        public let maxRecords: Int?

        @inlinable
        public init(filters: [DescribeIntegrationsFilter]? = nil, integrationArn: String? = nil, marker: String? = nil, maxRecords: Int? = nil) {
            self.filters = filters
            self.integrationArn = integrationArn
            self.marker = marker
            self.maxRecords = maxRecords
        }

        public func validate(name: String) throws {
            try self.filters?.forEach {
                try $0.validate(name: "\(name).filters[]")
            }
            try self.validate(self.integrationArn, name: "integrationArn", parent: name, max: 255)
            try self.validate(self.integrationArn, name: "integrationArn", parent: name, min: 1)
            try self.validate(self.integrationArn, name: "integrationArn", parent: name, pattern: "^arn:aws[a-z\\-]*:redshift:[a-z0-9\\-]*:[0-9]*:integration:[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$")
            try self.validate(self.marker, name: "marker", parent: name, max: 2147483647)
        }

        private enum CodingKeys: String, CodingKey {
            case filters = "Filters"
            case integrationArn = "IntegrationArn"
            case marker = "Marker"
            case maxRecords = "MaxRecords"
        }
    }

    public struct DescribeLoggingStatusMessage: AWSEncodableShape {
        /// The identifier of the cluster from which to get the logging status. Example: examplecluster
        public let clusterIdentifier: String?

        @inlinable
        public init(clusterIdentifier: String? = nil) {
            self.clusterIdentifier = clusterIdentifier
        }

        public func validate(name: String) throws {
            try self.validate(self.clusterIdentifier, name: "clusterIdentifier", parent: name, max: 2147483647)
        }

        private enum CodingKeys: String, CodingKey {
            case clusterIdentifier = "ClusterIdentifier"
        }
    }

    public struct DescribeNodeConfigurationOptionsMessage: AWSEncodableShape {
        public struct _FiltersEncoding: ArrayCoderProperties { public static let member = "NodeConfigurationOptionsFilter" }

        /// The action type to evaluate for possible node configurations. Specify "restore-cluster" to get configuration combinations based on an existing snapshot.  Specify "recommend-node-config" to get configuration recommendations based on an existing cluster or snapshot.  Specify "resize-cluster" to get configuration combinations for elastic resize based on an existing cluster.
        public let actionType: ActionType?
        /// The identifier of the cluster to evaluate for possible node configurations.
        public let clusterIdentifier: String?
        /// A set of name, operator, and value items to filter the results.
        @OptionalCustomCoding<ArrayCoder<_FiltersEncoding, NodeConfigurationOptionsFilter>>
        public var filters: [NodeConfigurationOptionsFilter]?
        /// An optional parameter that specifies the starting point to return a set of response records. When the results of a DescribeNodeConfigurationOptions request exceed the value specified in MaxRecords, Amazon Web Services returns a value in the Marker field of the response. You can retrieve the next set of response records by providing the returned marker value in the Marker parameter and retrying the request.
        public let marker: String?
        /// The maximum number of response records to return in each call. If the number of remaining response records exceeds the specified MaxRecords value, a value is returned in a marker field of the response. You can retrieve the next set of records by retrying the command with the returned marker value.  Default: 500  Constraints: minimum 100, maximum 500.
        public let maxRecords: Int?
        /// The Amazon Web Services account used to create or copy the snapshot.  Required if you are restoring a snapshot you do not own,  optional if you own the snapshot.
        public let ownerAccount: String?
        /// The Amazon Resource Name (ARN) of the snapshot associated with the message to describe node configuration.
        public let snapshotArn: String?
        /// The identifier of the snapshot to evaluate for possible node configurations.
        public let snapshotIdentifier: String?

        @inlinable
        public init(actionType: ActionType? = nil, clusterIdentifier: String? = nil, filters: [NodeConfigurationOptionsFilter]? = nil, marker: String? = nil, maxRecords: Int? = nil, ownerAccount: String? = nil, snapshotArn: String? = nil, snapshotIdentifier: String? = nil) {
            self.actionType = actionType
            self.clusterIdentifier = clusterIdentifier
            self.filters = filters
            self.marker = marker
            self.maxRecords = maxRecords
            self.ownerAccount = ownerAccount
            self.snapshotArn = snapshotArn
            self.snapshotIdentifier = snapshotIdentifier
        }

        public func validate(name: String) throws {
            try self.validate(self.clusterIdentifier, name: "clusterIdentifier", parent: name, max: 2147483647)
            try self.filters?.forEach {
                try $0.validate(name: "\(name).filters[]")
            }
            try self.validate(self.marker, name: "marker", parent: name, max: 2147483647)
            try self.validate(self.ownerAccount, name: "ownerAccount", parent: name, max: 2147483647)
            try self.validate(self.snapshotArn, name: "snapshotArn", parent: name, max: 2147483647)
            try self.validate(self.snapshotIdentifier, name: "snapshotIdentifier", parent: name, max: 2147483647)
        }

        private enum CodingKeys: String, CodingKey {
            case actionType = "ActionType"
            case clusterIdentifier = "ClusterIdentifier"
            case filters = "Filter"
            case marker = "Marker"
            case maxRecords = "MaxRecords"
            case ownerAccount = "OwnerAccount"
            case snapshotArn = "SnapshotArn"
            case snapshotIdentifier = "SnapshotIdentifier"
        }
    }

    public struct DescribeOrderableClusterOptionsMessage: AWSEncodableShape {
        /// The version filter value. Specify this parameter to show only the available offerings matching the specified version. Default: All versions. Constraints: Must be one of the version returned from DescribeClusterVersions.
        public let clusterVersion: String?
        /// An optional parameter that specifies the starting point to return a set of response records. When the results of a DescribeOrderableClusterOptions request exceed the value specified in MaxRecords, Amazon Web Services returns a value in the Marker field of the response. You can retrieve the next set of response records by providing the returned marker value in the Marker parameter and retrying the request.
        public let marker: String?
        /// The maximum number of response records to return in each call. If the number of remaining response records exceeds the specified MaxRecords value, a value is returned in a marker field of the response. You can retrieve the next set of records by retrying the command with the returned marker value.  Default: 100  Constraints: minimum 20, maximum 100.
        public let maxRecords: Int?
        /// The node type filter value. Specify this parameter to show only the available offerings matching the specified node type.
        public let nodeType: String?

        @inlinable
        public init(clusterVersion: String? = nil, marker: String? = nil, maxRecords: Int? = nil, nodeType: String? = nil) {
            self.clusterVersion = clusterVersion
            self.marker = marker
            self.maxRecords = maxRecords
            self.nodeType = nodeType
        }

        public func validate(name: String) throws {
            try self.validate(self.clusterVersion, name: "clusterVersion", parent: name, max: 2147483647)
            try self.validate(self.marker, name: "marker", parent: name, max: 2147483647)
            try self.validate(self.nodeType, name: "nodeType", parent: name, max: 2147483647)
        }

        private enum CodingKeys: String, CodingKey {
            case clusterVersion = "ClusterVersion"
            case marker = "Marker"
            case maxRecords = "MaxRecords"
            case nodeType = "NodeType"
        }
    }

    public struct DescribePartnersInputMessage: AWSEncodableShape {
        /// The Amazon Web Services account ID that owns the cluster.
        public let accountId: String?
        /// The cluster identifier of the cluster whose partner integration is being described.
        public let clusterIdentifier: String?
        /// The name of the database whose partner integration is being described. If database name is not specified, then all databases in the cluster are described.
        public let databaseName: String?
        /// The name of the partner that is being described. If partner name is not specified, then all partner integrations are described.
        public let partnerName: String?

        @inlinable
        public init(accountId: String? = nil, clusterIdentifier: String? = nil, databaseName: String? = nil, partnerName: String? = nil) {
            self.accountId = accountId
            self.clusterIdentifier = clusterIdentifier
            self.databaseName = databaseName
            self.partnerName = partnerName
        }

        public func validate(name: String) throws {
            try self.validate(self.accountId, name: "accountId", parent: name, max: 12)
            try self.validate(self.accountId, name: "accountId", parent: name, min: 12)
            try self.validate(self.accountId, name: "accountId", parent: name, pattern: "^[0-9]+$")
            try self.validate(self.clusterIdentifier, name: "clusterIdentifier", parent: name, max: 63)
            try self.validate(self.clusterIdentifier, name: "clusterIdentifier", parent: name, pattern: "^[a-zA-Z0-9\\-]+$")
            try self.validate(self.databaseName, name: "databaseName", parent: name, max: 127)
            try self.validate(self.databaseName, name: "databaseName", parent: name, pattern: "^[\\p{L}_][\\p{L}\\p{N}@$#_]+$")
            try self.validate(self.partnerName, name: "partnerName", parent: name, max: 255)
            try self.validate(self.partnerName, name: "partnerName", parent: name, pattern: "^[a-zA-Z0-9\\-_]+$")
        }

        private enum CodingKeys: String, CodingKey {
            case accountId = "AccountId"
            case clusterIdentifier = "ClusterIdentifier"
            case databaseName = "DatabaseName"
            case partnerName = "PartnerName"
        }
    }

    public struct DescribePartnersOutputMessage: AWSDecodableShape {
        public struct _PartnerIntegrationInfoListEncoding: ArrayCoderProperties { public static let member = "PartnerIntegrationInfo" }

        /// A list of partner integrations.
        @OptionalCustomCoding<ArrayCoder<_PartnerIntegrationInfoListEncoding, PartnerIntegrationInfo>>
        public var partnerIntegrationInfoList: [PartnerIntegrationInfo]?

        @inlinable
        public init(partnerIntegrationInfoList: [PartnerIntegrationInfo]? = nil) {
            self.partnerIntegrationInfoList = partnerIntegrationInfoList
        }

        private enum CodingKeys: String, CodingKey {
            case partnerIntegrationInfoList = "PartnerIntegrationInfoList"
        }
    }

    public struct DescribeRedshiftIdcApplicationsMessage: AWSEncodableShape {
        /// A value that indicates the starting point for the next set of response records in a subsequent request. If a  value is returned in a response, you can retrieve the next set of records by providing this returned marker value in the Marker parameter and retrying the command. If the Marker field is empty, all response records have been retrieved for the request.
        public let marker: String?
        /// The maximum number of response records to return in each call. If the number of remaining response records  exceeds the specified MaxRecords value, a value is returned in a marker field of the response. You can retrieve  the next set of records by retrying the command with the returned marker value.
        public let maxRecords: Int?
        /// The ARN for the Redshift application that integrates with IAM Identity Center.
        public let redshiftIdcApplicationArn: String?

        @inlinable
        public init(marker: String? = nil, maxRecords: Int? = nil, redshiftIdcApplicationArn: String? = nil) {
            self.marker = marker
            self.maxRecords = maxRecords
            self.redshiftIdcApplicationArn = redshiftIdcApplicationArn
        }

        public func validate(name: String) throws {
            try self.validate(self.marker, name: "marker", parent: name, max: 2147483647)
            try self.validate(self.redshiftIdcApplicationArn, name: "redshiftIdcApplicationArn", parent: name, max: 2147483647)
        }

        private enum CodingKeys: String, CodingKey {
            case marker = "Marker"
            case maxRecords = "MaxRecords"
            case redshiftIdcApplicationArn = "RedshiftIdcApplicationArn"
        }
    }

    public struct DescribeRedshiftIdcApplicationsResult: AWSDecodableShape {
        /// A value that indicates the starting point for the next set of response records in a subsequent  request. If a value is returned in a response, you can retrieve the next set of records by providing this returned marker value in the Marker parameter and retrying the command. If the Marker field is empty, all response records have been retrieved for the request.
        public let marker: String?
        /// The list of Amazon Redshift IAM Identity Center applications.
        @OptionalCustomCoding<StandardArrayCoder<RedshiftIdcApplication>>
        public var redshiftIdcApplications: [RedshiftIdcApplication]?

        @inlinable
        public init(marker: String? = nil, redshiftIdcApplications: [RedshiftIdcApplication]? = nil) {
            self.marker = marker
            self.redshiftIdcApplications = redshiftIdcApplications
        }

        private enum CodingKeys: String, CodingKey {
            case marker = "Marker"
            case redshiftIdcApplications = "RedshiftIdcApplications"
        }
    }

    public struct DescribeReservedNodeExchangeStatusInputMessage: AWSEncodableShape {
        /// An optional pagination token provided by a previous DescribeReservedNodeExchangeStatus request. If this  parameter is specified, the response includes only records beyond the marker, up to the value  specified by the MaxRecords parameter. You can retrieve the next set of response records by providing the returned marker value in the Marker parameter and retrying the request.
        public let marker: String?
        /// The maximum number of response records to return in each call. If the number of remaining response records exceeds the specified MaxRecords value, a value is returned in a Marker field of the response. You can retrieve the next set of records by retrying the command with the returned marker value.
        public let maxRecords: Int?
        /// The identifier of the reserved-node exchange request.
        public let reservedNodeExchangeRequestId: String?
        /// The identifier of the source reserved node in a reserved-node exchange request.
        public let reservedNodeId: String?

        @inlinable
        public init(marker: String? = nil, maxRecords: Int? = nil, reservedNodeExchangeRequestId: String? = nil, reservedNodeId: String? = nil) {
            self.marker = marker
            self.maxRecords = maxRecords
            self.reservedNodeExchangeRequestId = reservedNodeExchangeRequestId
            self.reservedNodeId = reservedNodeId
        }

        public func validate(name: String) throws {
            try self.validate(self.marker, name: "marker", parent: name, max: 2147483647)
            try self.validate(self.reservedNodeExchangeRequestId, name: "reservedNodeExchangeRequestId", parent: name, max: 2147483647)
            try self.validate(self.reservedNodeId, name: "reservedNodeId", parent: name, max: 2147483647)
        }

        private enum CodingKeys: String, CodingKey {
            case marker = "Marker"
            case maxRecords = "MaxRecords"
            case reservedNodeExchangeRequestId = "ReservedNodeExchangeRequestId"
            case reservedNodeId = "ReservedNodeId"
        }
    }

    public struct DescribeReservedNodeExchangeStatusOutputMessage: AWSDecodableShape {
        public struct _ReservedNodeExchangeStatusDetailsEncoding: ArrayCoderProperties { public static let member = "ReservedNodeExchangeStatus" }

        /// A pagination token provided by a previous DescribeReservedNodeExchangeStatus request.
        public let marker: String?
        /// The details of the reserved-node exchange request, including the status, request time, source reserved-node identifier, and additional details.
        @OptionalCustomCoding<ArrayCoder<_ReservedNodeExchangeStatusDetailsEncoding, ReservedNodeExchangeStatus>>
        public var reservedNodeExchangeStatusDetails: [ReservedNodeExchangeStatus]?

        @inlinable
        public init(marker: String? = nil, reservedNodeExchangeStatusDetails: [ReservedNodeExchangeStatus]? = nil) {
            self.marker = marker
            self.reservedNodeExchangeStatusDetails = reservedNodeExchangeStatusDetails
        }

        private enum CodingKeys: String, CodingKey {
            case marker = "Marker"
            case reservedNodeExchangeStatusDetails = "ReservedNodeExchangeStatusDetails"
        }
    }

    public struct DescribeReservedNodeOfferingsMessage: AWSEncodableShape {
        /// An optional parameter that specifies the starting point to return a set of response records. When the results of a DescribeReservedNodeOfferings request exceed the value specified in MaxRecords, Amazon Web Services returns a value in the Marker field of the response. You can retrieve the next set of response records by providing the returned marker value in the Marker parameter and retrying the request.
        public let marker: String?
        /// The maximum number of response records to return in each call. If the number of remaining response records exceeds the specified MaxRecords value, a value is returned in a marker field of the response. You can retrieve the next set of records by retrying the command with the returned marker value.  Default: 100  Constraints: minimum 20, maximum 100.
        public let maxRecords: Int?
        /// The unique identifier for the offering.
        public let reservedNodeOfferingId: String?

        @inlinable
        public init(marker: String? = nil, maxRecords: Int? = nil, reservedNodeOfferingId: String? = nil) {
            self.marker = marker
            self.maxRecords = maxRecords
            self.reservedNodeOfferingId = reservedNodeOfferingId
        }

        public func validate(name: String) throws {
            try self.validate(self.marker, name: "marker", parent: name, max: 2147483647)
            try self.validate(self.reservedNodeOfferingId, name: "reservedNodeOfferingId", parent: name, max: 2147483647)
        }

        private enum CodingKeys: String, CodingKey {
            case marker = "Marker"
            case maxRecords = "MaxRecords"
            case reservedNodeOfferingId = "ReservedNodeOfferingId"
        }
    }

    public struct DescribeReservedNodesMessage: AWSEncodableShape {
        /// An optional parameter that specifies the starting point to return a set of response records. When the results of a DescribeReservedNodes request exceed the value specified in MaxRecords, Amazon Web Services returns a value in the Marker field of the response. You can retrieve the next set of response records by providing the returned marker value in the Marker parameter and retrying the request.
        public let marker: String?
        /// The maximum number of response records to return in each call. If the number of remaining response records exceeds the specified MaxRecords value, a value is returned in a marker field of the response. You can retrieve the next set of records by retrying the command with the returned marker value.  Default: 100  Constraints: minimum 20, maximum 100.
        public let maxRecords: Int?
        /// Identifier for the node reservation.
        public let reservedNodeId: String?

        @inlinable
        public init(marker: String? = nil, maxRecords: Int? = nil, reservedNodeId: String? = nil) {
            self.marker = marker
            self.maxRecords = maxRecords
            self.reservedNodeId = reservedNodeId
        }

        public func validate(name: String) throws {
            try self.validate(self.marker, name: "marker", parent: name, max: 2147483647)
            try self.validate(self.reservedNodeId, name: "reservedNodeId", parent: name, max: 2147483647)
        }

        private enum CodingKeys: String, CodingKey {
            case marker = "Marker"
            case maxRecords = "MaxRecords"
            case reservedNodeId = "ReservedNodeId"
        }
    }

    public struct DescribeResizeMessage: AWSEncodableShape {
        /// The unique identifier of a cluster whose resize progress you are requesting. This parameter is case-sensitive. By default, resize operations for all clusters defined for an Amazon Web Services account are returned.
        public let clusterIdentifier: String?

        @inlinable
        public init(clusterIdentifier: String? = nil) {
            self.clusterIdentifier = clusterIdentifier
        }

        public func validate(name: String) throws {
            try self.validate(self.clusterIdentifier, name: "clusterIdentifier", parent: name, max: 2147483647)
        }

        private enum CodingKeys: String, CodingKey {
            case clusterIdentifier = "ClusterIdentifier"
        }
    }

    public struct DescribeScheduledActionsMessage: AWSEncodableShape {
        public struct _FiltersEncoding: ArrayCoderProperties { public static let member = "ScheduledActionFilter" }

        /// If true, retrieve only active scheduled actions.  If false, retrieve only disabled scheduled actions.
        public let active: Bool?
        /// The end time in UTC of the scheduled action to retrieve.  Only active scheduled actions that have invocations before this time are retrieved.
        public let endTime: Date?
        /// List of scheduled action filters.
        @OptionalCustomCoding<ArrayCoder<_FiltersEncoding, ScheduledActionFilter>>
        public var filters: [ScheduledActionFilter]?
        /// An optional parameter that specifies the starting point to return a set of response records. When the results of a DescribeScheduledActions request exceed the value specified in MaxRecords, Amazon Web Services returns a value in the Marker field of the response. You can retrieve the next set of response records by providing the returned marker value in the Marker parameter and retrying the request.
        public let marker: String?
        /// The maximum number of response records to return in each call. If the number of remaining response records exceeds the specified MaxRecords value, a value is returned in a marker field of the response. You can retrieve the next set of records by retrying the command with the returned marker value.  Default: 100  Constraints: minimum 20, maximum 100.
        public let maxRecords: Int?
        /// The name of the scheduled action to retrieve.
        public let scheduledActionName: String?
        /// The start time in UTC of the scheduled actions to retrieve.  Only active scheduled actions that have invocations after this time are retrieved.
        public let startTime: Date?
        /// The type of the scheduled actions to retrieve.
        public let targetActionType: ScheduledActionTypeValues?

        @inlinable
        public init(active: Bool? = nil, endTime: Date? = nil, filters: [ScheduledActionFilter]? = nil, marker: String? = nil, maxRecords: Int? = nil, scheduledActionName: String? = nil, startTime: Date? = nil, targetActionType: ScheduledActionTypeValues? = nil) {
            self.active = active
            self.endTime = endTime
            self.filters = filters
            self.marker = marker
            self.maxRecords = maxRecords
            self.scheduledActionName = scheduledActionName
            self.startTime = startTime
            self.targetActionType = targetActionType
        }

        public func validate(name: String) throws {
            try self.filters?.forEach {
                try $0.validate(name: "\(name).filters[]")
            }
            try self.validate(self.marker, name: "marker", parent: name, max: 2147483647)
            try self.validate(self.scheduledActionName, name: "scheduledActionName", parent: name, max: 2147483647)
        }

        private enum CodingKeys: String, CodingKey {
            case active = "Active"
            case endTime = "EndTime"
            case filters = "Filters"
            case marker = "Marker"
            case maxRecords = "MaxRecords"
            case scheduledActionName = "ScheduledActionName"
            case startTime = "StartTime"
            case targetActionType = "TargetActionType"
        }
    }

    public struct DescribeSnapshotCopyGrantsMessage: AWSEncodableShape {
        public struct _TagKeysEncoding: ArrayCoderProperties { public static let member = "TagKey" }
        public struct _TagValuesEncoding: ArrayCoderProperties { public static let member = "TagValue" }

        /// An optional parameter that specifies the starting point to return a set of response records. When the results of a DescribeSnapshotCopyGrant request exceed the value specified in MaxRecords, Amazon Web Services returns a value in the Marker field of the response. You can retrieve the next set of response records by providing the returned marker value in the Marker parameter and retrying the request.  Constraints: You can specify either the SnapshotCopyGrantName parameter or the Marker parameter, but not both.
        public let marker: String?
        /// The maximum number of response records to return in each call. If the number of remaining response records exceeds the specified MaxRecords value, a value is returned in a marker field of the response. You can retrieve the next set of records by retrying the command with the returned marker value.  Default: 100  Constraints: minimum 20, maximum 100.
        public let maxRecords: Int?
        /// The name of the snapshot copy grant.
        public let snapshotCopyGrantName: String?
        /// A tag key or keys for which you want to return all matching resources that are associated with the specified key or keys. For example, suppose that you have resources tagged with keys called owner and environment. If you specify both of these tag keys in the request, Amazon Redshift returns a response with all resources that have either or both of these tag keys associated with them.
        @OptionalCustomCoding<ArrayCoder<_TagKeysEncoding, String>>
        public var tagKeys: [String]?
        /// A tag value or values for which you want to return all matching resources that are associated with the specified value or values. For example, suppose that you have resources tagged with values called admin and test. If you specify both of these tag values in the request, Amazon Redshift returns a response with all resources that have either or both of these tag values associated with them.
        @OptionalCustomCoding<ArrayCoder<_TagValuesEncoding, String>>
        public var tagValues: [String]?

        @inlinable
        public init(marker: String? = nil, maxRecords: Int? = nil, snapshotCopyGrantName: String? = nil, tagKeys: [String]? = nil, tagValues: [String]? = nil) {
            self.marker = marker
            self.maxRecords = maxRecords
            self.snapshotCopyGrantName = snapshotCopyGrantName
            self.tagKeys = tagKeys
            self.tagValues = tagValues
        }

        public func validate(name: String) throws {
            try self.validate(self.marker, name: "marker", parent: name, max: 2147483647)
            try self.validate(self.snapshotCopyGrantName, name: "snapshotCopyGrantName", parent: name, max: 2147483647)
            try self.tagKeys?.forEach {
                try validate($0, name: "tagKeys[]", parent: name, max: 2147483647)
            }
            try self.tagValues?.forEach {
                try validate($0, name: "tagValues[]", parent: name, max: 2147483647)
            }
        }

        private enum CodingKeys: String, CodingKey {
            case marker = "Marker"
            case maxRecords = "MaxRecords"
            case snapshotCopyGrantName = "SnapshotCopyGrantName"
            case tagKeys = "TagKeys"
            case tagValues = "TagValues"
        }
    }

    public struct DescribeSnapshotSchedulesMessage: AWSEncodableShape {
        public struct _TagKeysEncoding: ArrayCoderProperties { public static let member = "TagKey" }
        public struct _TagValuesEncoding: ArrayCoderProperties { public static let member = "TagValue" }

        /// The unique identifier for the cluster whose snapshot schedules you want to view.
        public let clusterIdentifier: String?
        /// A value that indicates the starting point for the next set of response records in a subsequent request. If a value is returned in a response, you can retrieve the next set of records by providing this returned marker value in the marker parameter and retrying the command. If the marker field is empty, all response records have been retrieved for the request.
        public let marker: String?
        /// The maximum number or response records to return in each call. If the number of remaining response records exceeds the specified MaxRecords value, a value is returned in a marker field of the response. You can retrieve the next set of records by retrying the command with the returned marker value.
        public let maxRecords: Int?
        /// A unique identifier for a snapshot schedule.
        public let scheduleIdentifier: String?
        /// The key value for a snapshot schedule tag.
        @OptionalCustomCoding<ArrayCoder<_TagKeysEncoding, String>>
        public var tagKeys: [String]?
        /// The value corresponding to the key of the snapshot schedule tag.
        @OptionalCustomCoding<ArrayCoder<_TagValuesEncoding, String>>
        public var tagValues: [String]?

        @inlinable
        public init(clusterIdentifier: String? = nil, marker: String? = nil, maxRecords: Int? = nil, scheduleIdentifier: String? = nil, tagKeys: [String]? = nil, tagValues: [String]? = nil) {
            self.clusterIdentifier = clusterIdentifier
            self.marker = marker
            self.maxRecords = maxRecords
            self.scheduleIdentifier = scheduleIdentifier
            self.tagKeys = tagKeys
            self.tagValues = tagValues
        }

        public func validate(name: String) throws {
            try self.validate(self.clusterIdentifier, name: "clusterIdentifier", parent: name, max: 2147483647)
            try self.validate(self.marker, name: "marker", parent: name, max: 2147483647)
            try self.validate(self.scheduleIdentifier, name: "scheduleIdentifier", parent: name, max: 2147483647)
            try self.tagKeys?.forEach {
                try validate($0, name: "tagKeys[]", parent: name, max: 2147483647)
            }
            try self.tagValues?.forEach {
                try validate($0, name: "tagValues[]", parent: name, max: 2147483647)
            }
        }

        private enum CodingKeys: String, CodingKey {
            case clusterIdentifier = "ClusterIdentifier"
            case marker = "Marker"
            case maxRecords = "MaxRecords"
            case scheduleIdentifier = "ScheduleIdentifier"
            case tagKeys = "TagKeys"
            case tagValues = "TagValues"
        }
    }

    public struct DescribeSnapshotSchedulesOutputMessage: AWSDecodableShape {
        public struct _SnapshotSchedulesEncoding: ArrayCoderProperties { public static let member = "SnapshotSchedule" }

        /// A value that indicates the starting point for the next set of response records in a subsequent request. If a value is returned in a response, you can retrieve the next set of records by providing this returned marker value in the marker parameter and retrying the command. If the marker field is empty, all response records have been retrieved for the request.
        public let marker: String?
        /// A list of SnapshotSchedules.
        @OptionalCustomCoding<ArrayCoder<_SnapshotSchedulesEncoding, SnapshotSchedule>>
        public var snapshotSchedules: [SnapshotSchedule]?

        @inlinable
        public init(marker: String? = nil, snapshotSchedules: [SnapshotSchedule]? = nil) {
            self.marker = marker
            self.snapshotSchedules = snapshotSchedules
        }

        private enum CodingKeys: String, CodingKey {
            case marker = "Marker"
            case snapshotSchedules = "SnapshotSchedules"
        }
    }

    public struct DescribeTableRestoreStatusMessage: AWSEncodableShape {
        /// The Amazon Redshift cluster that the table is being restored to.
        public let clusterIdentifier: String?
        /// An optional pagination token provided by a previous DescribeTableRestoreStatus request. If this parameter is specified, the response includes only records beyond the marker, up to the value specified by the MaxRecords parameter.
        public let marker: String?
        /// The maximum number of records to include in the response. If more records exist than the specified MaxRecords value, a pagination token called a marker is included in the response so that the remaining results can be retrieved.
        public let maxRecords: Int?
        /// The identifier of the table restore request to return status for. If you don't specify a TableRestoreRequestId value, then DescribeTableRestoreStatus returns the status of all in-progress table restore requests.
        public let tableRestoreRequestId: String?

        @inlinable
        public init(clusterIdentifier: String? = nil, marker: String? = nil, maxRecords: Int? = nil, tableRestoreRequestId: String? = nil) {
            self.clusterIdentifier = clusterIdentifier
            self.marker = marker
            self.maxRecords = maxRecords
            self.tableRestoreRequestId = tableRestoreRequestId
        }

        public func validate(name: String) throws {
            try self.validate(self.clusterIdentifier, name: "clusterIdentifier", parent: name, max: 2147483647)
            try self.validate(self.marker, name: "marker", parent: name, max: 2147483647)
            try self.validate(self.tableRestoreRequestId, name: "tableRestoreRequestId", parent: name, max: 2147483647)
        }

        private enum CodingKeys: String, CodingKey {
            case clusterIdentifier = "ClusterIdentifier"
            case marker = "Marker"
            case maxRecords = "MaxRecords"
            case tableRestoreRequestId = "TableRestoreRequestId"
        }
    }

    public struct DescribeTagsMessage: AWSEncodableShape {
        public struct _TagKeysEncoding: ArrayCoderProperties { public static let member = "TagKey" }
        public struct _TagValuesEncoding: ArrayCoderProperties { public static let member = "TagValue" }

        /// A value that indicates the starting point for the next set of response records in a subsequent request. If a value is returned in a response, you can retrieve the next set of records by providing this returned marker value in the marker parameter and retrying the command. If the marker field is empty, all response records have been retrieved for the request.
        public let marker: String?
        /// The maximum number or response records to return in each call. If the number of remaining response records exceeds the specified MaxRecords value, a value is returned in a marker field of the response. You can retrieve the next set of records by retrying the command with the returned marker value.
        public let maxRecords: Int?
        /// The Amazon Resource Name (ARN) for which you want to describe the tag or tags. For example, arn:aws:redshift:us-east-2:123456789:cluster:t1.
        public let resourceName: String?
        /// The type of resource with which you want to view tags. Valid resource types are:    Cluster   CIDR/IP   EC2 security group   Snapshot   Cluster security group   Subnet group   HSM connection   HSM certificate   Parameter group   Snapshot copy grant   Integration (zero-ETL integration or S3 event integration)  To describe the tags associated with an integration, don't specify ResourceType,  instead specify the ResourceName of the integration.    For more information about Amazon Redshift resource types and constructing ARNs, go to Specifying Policy Elements: Actions, Effects, Resources, and Principals in the Amazon Redshift Cluster Management Guide.
        public let resourceType: String?
        /// A tag key or keys for which you want to return all matching resources that are associated with the specified key or keys. For example, suppose that you have resources tagged with keys called owner and environment. If you specify both of these tag keys in the request, Amazon Redshift returns a response with all resources that have either or both of these tag keys associated with them.
        @OptionalCustomCoding<ArrayCoder<_TagKeysEncoding, String>>
        public var tagKeys: [String]?
        /// A tag value or values for which you want to return all matching resources that are associated with the specified value or values. For example, suppose that you have resources tagged with values called admin and test. If you specify both of these tag values in the request, Amazon Redshift returns a response with all resources that have either or both of these tag values associated with them.
        @OptionalCustomCoding<ArrayCoder<_TagValuesEncoding, String>>
        public var tagValues: [String]?

        @inlinable
        public init(marker: String? = nil, maxRecords: Int? = nil, resourceName: String? = nil, resourceType: String? = nil, tagKeys: [String]? = nil, tagValues: [String]? = nil) {
            self.marker = marker
            self.maxRecords = maxRecords
            self.resourceName = resourceName
            self.resourceType = resourceType
            self.tagKeys = tagKeys
            self.tagValues = tagValues
        }

        public func validate(name: String) throws {
            try self.validate(self.marker, name: "marker", parent: name, max: 2147483647)
            try self.validate(self.resourceName, name: "resourceName", parent: name, max: 2147483647)
            try self.validate(self.resourceType, name: "resourceType", parent: name, max: 2147483647)
            try self.tagKeys?.forEach {
                try validate($0, name: "tagKeys[]", parent: name, max: 2147483647)
            }
            try self.tagValues?.forEach {
                try validate($0, name: "tagValues[]", parent: name, max: 2147483647)
            }
        }

        private enum CodingKeys: String, CodingKey {
            case marker = "Marker"
            case maxRecords = "MaxRecords"
            case resourceName = "ResourceName"
            case resourceType = "ResourceType"
            case tagKeys = "TagKeys"
            case tagValues = "TagValues"
        }
    }

    public struct DescribeUsageLimitsMessage: AWSEncodableShape {
        public struct _TagKeysEncoding: ArrayCoderProperties { public static let member = "TagKey" }
        public struct _TagValuesEncoding: ArrayCoderProperties { public static let member = "TagValue" }

        /// The identifier of the cluster for which you want to describe usage limits.
        public let clusterIdentifier: String?
        /// The feature type for which you want to describe usage limits.
        public let featureType: UsageLimitFeatureType?
        /// An optional parameter that specifies the starting point to return a set of response records. When the results of a DescribeUsageLimits request exceed the value specified in MaxRecords, Amazon Web Services returns a value in the Marker field of the response. You can retrieve the next set of response records by providing the returned marker value in the Marker parameter and retrying the request.
        public let marker: String?
        /// The maximum number of response records to return in each call. If the number of remaining response records exceeds the specified MaxRecords value, a value is returned in a marker field of the response. You can retrieve the next set of records by retrying the command with the returned marker value.  Default: 100  Constraints: minimum 20, maximum 100.
        public let maxRecords: Int?
        /// A tag key or keys for which you want to return all matching usage limit objects that are associated with the specified key or keys. For example, suppose that you have parameter groups that are tagged with keys called owner and environment. If you specify both of these tag keys in the request, Amazon Redshift returns a response with the usage limit objects have either or both of these tag keys associated with them.
        @OptionalCustomCoding<ArrayCoder<_TagKeysEncoding, String>>
        public var tagKeys: [String]?
        /// A tag value or values for which you want to return all matching usage limit objects that are associated with the specified tag value or values. For example, suppose that you have parameter groups that are tagged with values called admin and test. If you specify both of these tag values in the request, Amazon Redshift returns a response with the usage limit objects that have either or both of these tag values associated with them.
        @OptionalCustomCoding<ArrayCoder<_TagValuesEncoding, String>>
        public var tagValues: [String]?
        /// The identifier of the usage limit to describe.
        public let usageLimitId: String?

        @inlinable
        public init(clusterIdentifier: String? = nil, featureType: UsageLimitFeatureType? = nil, marker: String? = nil, maxRecords: Int? = nil, tagKeys: [String]? = nil, tagValues: [String]? = nil, usageLimitId: String? = nil) {
            self.clusterIdentifier = clusterIdentifier
            self.featureType = featureType
            self.marker = marker
            self.maxRecords = maxRecords
            self.tagKeys = tagKeys
            self.tagValues = tagValues
            self.usageLimitId = usageLimitId
        }

        public func validate(name: String) throws {
            try self.validate(self.clusterIdentifier, name: "clusterIdentifier", parent: name, max: 2147483647)
            try self.validate(self.marker, name: "marker", parent: name, max: 2147483647)
            try self.tagKeys?.forEach {
                try validate($0, name: "tagKeys[]", parent: name, max: 2147483647)
            }
            try self.tagValues?.forEach {
                try validate($0, name: "tagValues[]", parent: name, max: 2147483647)
            }
            try self.validate(self.usageLimitId, name: "usageLimitId", parent: name, max: 2147483647)
        }

        private enum CodingKeys: String, CodingKey {
            case clusterIdentifier = "ClusterIdentifier"
            case featureType = "FeatureType"
            case marker = "Marker"
            case maxRecords = "MaxRecords"
            case tagKeys = "TagKeys"
            case tagValues = "TagValues"
            case usageLimitId = "UsageLimitId"
        }
    }

    public struct DisableLoggingMessage: AWSEncodableShape {
        /// The identifier of the cluster on which logging is to be stopped. Example: examplecluster
        public let clusterIdentifier: String?

        @inlinable
        public init(clusterIdentifier: String? = nil) {
            self.clusterIdentifier = clusterIdentifier
        }

        public func validate(name: String) throws {
            try self.validate(self.clusterIdentifier, name: "clusterIdentifier", parent: name, max: 2147483647)
        }

        private enum CodingKeys: String, CodingKey {
            case clusterIdentifier = "ClusterIdentifier"
        }
    }

    public struct DisableSnapshotCopyMessage: AWSEncodableShape {
        /// The unique identifier of the source cluster that you want to disable copying of snapshots to a destination region. Constraints: Must be the valid name of an existing cluster that has cross-region snapshot copy enabled.
        public let clusterIdentifier: String?

        @inlinable
        public init(clusterIdentifier: String? = nil) {
            self.clusterIdentifier = clusterIdentifier
        }

        public func validate(name: String) throws {
            try self.validate(self.clusterIdentifier, name: "clusterIdentifier", parent: name, max: 2147483647)
        }

        private enum CodingKeys: String, CodingKey {
            case clusterIdentifier = "ClusterIdentifier"
        }
    }

    public struct DisableSnapshotCopyResult: AWSDecodableShape {
        public let cluster: Cluster?

        @inlinable
        public init(cluster: Cluster? = nil) {
            self.cluster = cluster
        }

        private enum CodingKeys: String, CodingKey {
            case cluster = "Cluster"
        }
    }

    public struct DisassociateDataShareConsumerMessage: AWSEncodableShape {
        /// The Amazon Resource Name (ARN) of the consumer namespace that association for the datashare is removed from.
        public let consumerArn: String?
        /// From a datashare consumer account, removes association of a datashare from all the existing and future namespaces in the specified Amazon Web Services Region.
        public let consumerRegion: String?
        /// The Amazon Resource Name (ARN) of the datashare to remove association for.
        public let dataShareArn: String?
        /// A value that specifies whether association for the datashare is removed from the entire account.
        public let disassociateEntireAccount: Bool?

        @inlinable
        public init(consumerArn: String? = nil, consumerRegion: String? = nil, dataShareArn: String? = nil, disassociateEntireAccount: Bool? = nil) {
            self.consumerArn = consumerArn
            self.consumerRegion = consumerRegion
            self.dataShareArn = dataShareArn
            self.disassociateEntireAccount = disassociateEntireAccount
        }

        public func validate(name: String) throws {
            try self.validate(self.consumerArn, name: "consumerArn", parent: name, max: 2147483647)
            try self.validate(self.consumerRegion, name: "consumerRegion", parent: name, max: 2147483647)
            try self.validate(self.dataShareArn, name: "dataShareArn", parent: name, max: 2147483647)
        }

        private enum CodingKeys: String, CodingKey {
            case consumerArn = "ConsumerArn"
            case consumerRegion = "ConsumerRegion"
            case dataShareArn = "DataShareArn"
            case disassociateEntireAccount = "DisassociateEntireAccount"
        }
    }

    public struct EC2SecurityGroup: AWSDecodableShape {
        public struct _TagsEncoding: ArrayCoderProperties { public static let member = "Tag" }

        /// The name of the EC2 Security Group.
        public let ec2SecurityGroupName: String?
        /// The Amazon Web Services account ID of the owner of the EC2 security group specified in the EC2SecurityGroupName field.
        public let ec2SecurityGroupOwnerId: String?
        /// The status of the EC2 security group.
        public let status: String?
        /// The list of tags for the EC2 security group.
        @OptionalCustomCoding<ArrayCoder<_TagsEncoding, Tag>>
        public var tags: [Tag]?

        @inlinable
        public init(ec2SecurityGroupName: String? = nil, ec2SecurityGroupOwnerId: String? = nil, status: String? = nil, tags: [Tag]? = nil) {
            self.ec2SecurityGroupName = ec2SecurityGroupName
            self.ec2SecurityGroupOwnerId = ec2SecurityGroupOwnerId
            self.status = status
            self.tags = tags
        }

        private enum CodingKeys: String, CodingKey {
            case ec2SecurityGroupName = "EC2SecurityGroupName"
            case ec2SecurityGroupOwnerId = "EC2SecurityGroupOwnerId"
            case status = "Status"
            case tags = "Tags"
        }
    }

    public struct ElasticIpStatus: AWSDecodableShape {
        /// The elastic IP (EIP) address for the cluster.
        public let elasticIp: String?
        /// The status of the elastic IP (EIP) address.
        public let status: String?

        @inlinable
        public init(elasticIp: String? = nil, status: String? = nil) {
            self.elasticIp = elasticIp
            self.status = status
        }

        private enum CodingKeys: String, CodingKey {
            case elasticIp = "ElasticIp"
            case status = "Status"
        }
    }

    public struct EnableLoggingMessage: AWSEncodableShape {
        /// The name of an existing S3 bucket where the log files are to be stored. Constraints:   Must be in the same region as the cluster   The cluster must have read bucket and put object permissions
        public let bucketName: String?
        /// The identifier of the cluster on which logging is to be started. Example: examplecluster
        public let clusterIdentifier: String?
        /// The log destination type. An enum with possible values of s3 and cloudwatch.
        public let logDestinationType: LogDestinationType?
        /// The collection of exported log types. Possible values are connectionlog, useractivitylog, and userlog.
        @OptionalCustomCoding<StandardArrayCoder<String>>
        public var logExports: [String]?
        /// The prefix applied to the log file names. Valid characters are any letter from any language, any whitespace character, any numeric character, and the following characters:  underscore (_), period (.), colon (:), slash (/), equal (=), plus (+), backslash (\), hyphen (-), at symbol (@).
        public let s3KeyPrefix: String?

        @inlinable
        public init(bucketName: String? = nil, clusterIdentifier: String? = nil, logDestinationType: LogDestinationType? = nil, logExports: [String]? = nil, s3KeyPrefix: String? = nil) {
            self.bucketName = bucketName
            self.clusterIdentifier = clusterIdentifier
            self.logDestinationType = logDestinationType
            self.logExports = logExports
            self.s3KeyPrefix = s3KeyPrefix
        }

        public func validate(name: String) throws {
            try self.validate(self.bucketName, name: "bucketName", parent: name, max: 2147483647)
            try self.validate(self.clusterIdentifier, name: "clusterIdentifier", parent: name, max: 2147483647)
            try self.logExports?.forEach {
                try validate($0, name: "logExports[]", parent: name, max: 2147483647)
            }
            try self.validate(self.s3KeyPrefix, name: "s3KeyPrefix", parent: name, max: 256)
            try self.validate(self.s3KeyPrefix, name: "s3KeyPrefix", parent: name, pattern: "^[\\p{L}\\p{Z}\\p{N}_.:/=+\\-@]*$")
        }

        private enum CodingKeys: String, CodingKey {
            case bucketName = "BucketName"
            case clusterIdentifier = "ClusterIdentifier"
            case logDestinationType = "LogDestinationType"
            case logExports = "LogExports"
            case s3KeyPrefix = "S3KeyPrefix"
        }
    }

    public struct EnableSnapshotCopyMessage: AWSEncodableShape {
        /// The unique identifier of the source cluster to copy snapshots from. Constraints: Must be the valid name of an existing cluster that does not already have cross-region snapshot copy enabled.
        public let clusterIdentifier: String?
        /// The destination Amazon Web Services Region that you want to copy snapshots to. Constraints: Must be the name of a valid Amazon Web Services Region. For more information, see Regions and Endpoints in the Amazon Web Services General Reference.
        public let destinationRegion: String?
        /// The number of days to retain newly copied snapshots in the destination Amazon Web Services Region after they are copied from the source Amazon Web Services Region. If the value is -1, the manual snapshot is retained indefinitely.  The value must be either -1 or an integer between 1 and 3,653.
        public let manualSnapshotRetentionPeriod: Int?
        /// The number of days to retain automated snapshots in the destination region after they are copied from the source region. Default: 7. Constraints: Must be at least 1 and no more than 35.
        public let retentionPeriod: Int?
        /// The name of the snapshot copy grant to use when snapshots of an Amazon Web Services KMS-encrypted cluster are copied to the destination region.
        public let snapshotCopyGrantName: String?

        @inlinable
        public init(clusterIdentifier: String? = nil, destinationRegion: String? = nil, manualSnapshotRetentionPeriod: Int? = nil, retentionPeriod: Int? = nil, snapshotCopyGrantName: String? = nil) {
            self.clusterIdentifier = clusterIdentifier
            self.destinationRegion = destinationRegion
            self.manualSnapshotRetentionPeriod = manualSnapshotRetentionPeriod
            self.retentionPeriod = retentionPeriod
            self.snapshotCopyGrantName = snapshotCopyGrantName
        }

        public func validate(name: String) throws {
            try self.validate(self.clusterIdentifier, name: "clusterIdentifier", parent: name, max: 2147483647)
            try self.validate(self.destinationRegion, name: "destinationRegion", parent: name, max: 2147483647)
            try self.validate(self.snapshotCopyGrantName, name: "snapshotCopyGrantName", parent: name, max: 2147483647)
        }

        private enum CodingKeys: String, CodingKey {
            case clusterIdentifier = "ClusterIdentifier"
            case destinationRegion = "DestinationRegion"
            case manualSnapshotRetentionPeriod = "ManualSnapshotRetentionPeriod"
            case retentionPeriod = "RetentionPeriod"
            case snapshotCopyGrantName = "SnapshotCopyGrantName"
        }
    }

    public struct EnableSnapshotCopyResult: AWSDecodableShape {
        public let cluster: Cluster?

        @inlinable
        public init(cluster: Cluster? = nil) {
            self.cluster = cluster
        }

        private enum CodingKeys: String, CodingKey {
            case cluster = "Cluster"
        }
    }

    public struct Endpoint: AWSDecodableShape {
        public struct _VpcEndpointsEncoding: ArrayCoderProperties { public static let member = "VpcEndpoint" }

        /// The DNS address of the Cluster.
        public let address: String?
        /// The port that the database engine is listening on.
        public let port: Int?
        /// Describes a connection endpoint.
        @OptionalCustomCoding<ArrayCoder<_VpcEndpointsEncoding, VpcEndpoint>>
        public var vpcEndpoints: [VpcEndpoint]?

        @inlinable
        public init(address: String? = nil, port: Int? = nil, vpcEndpoints: [VpcEndpoint]? = nil) {
            self.address = address
            self.port = port
            self.vpcEndpoints = vpcEndpoints
        }

        private enum CodingKeys: String, CodingKey {
            case address = "Address"
            case port = "Port"
            case vpcEndpoints = "VpcEndpoints"
        }
    }

    public struct EndpointAccess: AWSDecodableShape {
        public struct _VpcSecurityGroupsEncoding: ArrayCoderProperties { public static let member = "VpcSecurityGroup" }

        /// The DNS address of the endpoint.
        public let address: String?
        /// The cluster identifier of the cluster associated with the endpoint.
        public let clusterIdentifier: String?
        /// The time (UTC) that the endpoint was created.
        public let endpointCreateTime: Date?
        /// The name of the endpoint.
        public let endpointName: String?
        /// The status of the endpoint.
        public let endpointStatus: String?
        /// The port number on which the cluster accepts incoming connections.
        public let port: Int?
        /// The Amazon Web Services account ID of the owner of the cluster.
        public let resourceOwner: String?
        /// The subnet group name where Amazon Redshift chooses to deploy the endpoint.
        public let subnetGroupName: String?
        public let vpcEndpoint: VpcEndpoint?
        /// The security groups associated with the endpoint.
        @OptionalCustomCoding<ArrayCoder<_VpcSecurityGroupsEncoding, VpcSecurityGroupMembership>>
        public var vpcSecurityGroups: [VpcSecurityGroupMembership]?

        @inlinable
        public init(address: String? = nil, clusterIdentifier: String? = nil, endpointCreateTime: Date? = nil, endpointName: String? = nil, endpointStatus: String? = nil, port: Int? = nil, resourceOwner: String? = nil, subnetGroupName: String? = nil, vpcEndpoint: VpcEndpoint? = nil, vpcSecurityGroups: [VpcSecurityGroupMembership]? = nil) {
            self.address = address
            self.clusterIdentifier = clusterIdentifier
            self.endpointCreateTime = endpointCreateTime
            self.endpointName = endpointName
            self.endpointStatus = endpointStatus
            self.port = port
            self.resourceOwner = resourceOwner
            self.subnetGroupName = subnetGroupName
            self.vpcEndpoint = vpcEndpoint
            self.vpcSecurityGroups = vpcSecurityGroups
        }

        private enum CodingKeys: String, CodingKey {
            case address = "Address"
            case clusterIdentifier = "ClusterIdentifier"
            case endpointCreateTime = "EndpointCreateTime"
            case endpointName = "EndpointName"
            case endpointStatus = "EndpointStatus"
            case port = "Port"
            case resourceOwner = "ResourceOwner"
            case subnetGroupName = "SubnetGroupName"
            case vpcEndpoint = "VpcEndpoint"
            case vpcSecurityGroups = "VpcSecurityGroups"
        }
    }

    public struct EndpointAccessList: AWSDecodableShape {
        /// The list of endpoints with access to the cluster.
        @OptionalCustomCoding<StandardArrayCoder<EndpointAccess>>
        public var endpointAccessList: [EndpointAccess]?
        /// An optional pagination token provided by a previous DescribeEndpointAccess request. If this parameter is specified, the response includes only records beyond the marker, up to the value specified by the MaxRecords parameter.
        public let marker: String?

        @inlinable
        public init(endpointAccessList: [EndpointAccess]? = nil, marker: String? = nil) {
            self.endpointAccessList = endpointAccessList
            self.marker = marker
        }

        private enum CodingKeys: String, CodingKey {
            case endpointAccessList = "EndpointAccessList"
            case marker = "Marker"
        }
    }

    public struct EndpointAuthorization: AWSDecodableShape {
        public struct _AllowedVPCsEncoding: ArrayCoderProperties { public static let member = "VpcIdentifier" }

        /// Indicates whether all VPCs in the grantee account are allowed access to the cluster.
        public let allowedAllVPCs: Bool?
        /// The VPCs allowed access to the cluster.
        @OptionalCustomCoding<ArrayCoder<_AllowedVPCsEncoding, String>>
        public var allowedVPCs: [String]?
        /// The time (UTC) when the authorization was created.
        public let authorizeTime: Date?
        /// The cluster identifier.
        public let clusterIdentifier: String?
        /// The status of the cluster.
        public let clusterStatus: String?
        /// The number of Redshift-managed VPC endpoints created for the authorization.
        public let endpointCount: Int?
        /// The Amazon Web Services account ID of the grantee of the cluster.
        public let grantee: String?
        /// The Amazon Web Services account ID of the cluster owner.
        public let grantor: String?
        /// The status of the authorization action.
        public let status: AuthorizationStatus?

        @inlinable
        public init(allowedAllVPCs: Bool? = nil, allowedVPCs: [String]? = nil, authorizeTime: Date? = nil, clusterIdentifier: String? = nil, clusterStatus: String? = nil, endpointCount: Int? = nil, grantee: String? = nil, grantor: String? = nil, status: AuthorizationStatus? = nil) {
            self.allowedAllVPCs = allowedAllVPCs
            self.allowedVPCs = allowedVPCs
            self.authorizeTime = authorizeTime
            self.clusterIdentifier = clusterIdentifier
            self.clusterStatus = clusterStatus
            self.endpointCount = endpointCount
            self.grantee = grantee
            self.grantor = grantor
            self.status = status
        }

        private enum CodingKeys: String, CodingKey {
            case allowedAllVPCs = "AllowedAllVPCs"
            case allowedVPCs = "AllowedVPCs"
            case authorizeTime = "AuthorizeTime"
            case clusterIdentifier = "ClusterIdentifier"
            case clusterStatus = "ClusterStatus"
            case endpointCount = "EndpointCount"
            case grantee = "Grantee"
            case grantor = "Grantor"
            case status = "Status"
        }
    }

    public struct EndpointAuthorizationList: AWSDecodableShape {
        /// The authorizations to an endpoint.
        @OptionalCustomCoding<StandardArrayCoder<EndpointAuthorization>>
        public var endpointAuthorizationList: [EndpointAuthorization]?
        /// An optional pagination token provided by a previous DescribeEndpointAuthorization request. If this parameter is specified, the response includes only records beyond the marker, up to the value specified by the MaxRecords parameter.
        public let marker: String?

        @inlinable
        public init(endpointAuthorizationList: [EndpointAuthorization]? = nil, marker: String? = nil) {
            self.endpointAuthorizationList = endpointAuthorizationList
            self.marker = marker
        }

        private enum CodingKeys: String, CodingKey {
            case endpointAuthorizationList = "EndpointAuthorizationList"
            case marker = "Marker"
        }
    }

    public struct Event: AWSDecodableShape {
        public struct _EventCategoriesEncoding: ArrayCoderProperties { public static let member = "EventCategory" }

        /// The date and time of the event.
        public let date: Date?
        /// A list of the event categories. Values: Configuration, Management, Monitoring, Security, Pending
        @OptionalCustomCoding<ArrayCoder<_EventCategoriesEncoding, String>>
        public var eventCategories: [String]?
        /// The identifier of the event.
        public let eventId: String?
        /// The text of this event.
        public let message: String?
        /// The severity of the event. Values: ERROR, INFO
        public let severity: String?
        /// The identifier for the source of the event.
        public let sourceIdentifier: String?
        /// The source type for this event.
        public let sourceType: SourceType?

        @inlinable
        public init(date: Date? = nil, eventCategories: [String]? = nil, eventId: String? = nil, message: String? = nil, severity: String? = nil, sourceIdentifier: String? = nil, sourceType: SourceType? = nil) {
            self.date = date
            self.eventCategories = eventCategories
            self.eventId = eventId
            self.message = message
            self.severity = severity
            self.sourceIdentifier = sourceIdentifier
            self.sourceType = sourceType
        }

        private enum CodingKeys: String, CodingKey {
            case date = "Date"
            case eventCategories = "EventCategories"
            case eventId = "EventId"
            case message = "Message"
            case severity = "Severity"
            case sourceIdentifier = "SourceIdentifier"
            case sourceType = "SourceType"
        }
    }

    public struct EventCategoriesMap: AWSDecodableShape {
        public struct _EventsEncoding: ArrayCoderProperties { public static let member = "EventInfoMap" }

        /// The events in the event category.
        @OptionalCustomCoding<ArrayCoder<_EventsEncoding, EventInfoMap>>
        public var events: [EventInfoMap]?
        /// The source type, such as cluster or cluster-snapshot, that the returned categories belong to.
        public let sourceType: String?

        @inlinable
        public init(events: [EventInfoMap]? = nil, sourceType: String? = nil) {
            self.events = events
            self.sourceType = sourceType
        }

        private enum CodingKeys: String, CodingKey {
            case events = "Events"
            case sourceType = "SourceType"
        }
    }

    public struct EventCategoriesMessage: AWSDecodableShape {
        public struct _EventCategoriesMapListEncoding: ArrayCoderProperties { public static let member = "EventCategoriesMap" }

        /// A list of event categories descriptions.
        @OptionalCustomCoding<ArrayCoder<_EventCategoriesMapListEncoding, EventCategoriesMap>>
        public var eventCategoriesMapList: [EventCategoriesMap]?

        @inlinable
        public init(eventCategoriesMapList: [EventCategoriesMap]? = nil) {
            self.eventCategoriesMapList = eventCategoriesMapList
        }

        private enum CodingKeys: String, CodingKey {
            case eventCategoriesMapList = "EventCategoriesMapList"
        }
    }

    public struct EventInfoMap: AWSDecodableShape {
        public struct _EventCategoriesEncoding: ArrayCoderProperties { public static let member = "EventCategory" }

        /// The category of an Amazon Redshift event.
        @OptionalCustomCoding<ArrayCoder<_EventCategoriesEncoding, String>>
        public var eventCategories: [String]?
        /// The description of an Amazon Redshift event.
        public let eventDescription: String?
        /// The identifier of an Amazon Redshift event.
        public let eventId: String?
        /// The severity of the event. Values: ERROR, INFO
        public let severity: String?

        @inlinable
        public init(eventCategories: [String]? = nil, eventDescription: String? = nil, eventId: String? = nil, severity: String? = nil) {
            self.eventCategories = eventCategories
            self.eventDescription = eventDescription
            self.eventId = eventId
            self.severity = severity
        }

        private enum CodingKeys: String, CodingKey {
            case eventCategories = "EventCategories"
            case eventDescription = "EventDescription"
            case eventId = "EventId"
            case severity = "Severity"
        }
    }

    public struct EventSubscription: AWSDecodableShape {
        public struct _EventCategoriesListEncoding: ArrayCoderProperties { public static let member = "EventCategory" }
        public struct _SourceIdsListEncoding: ArrayCoderProperties { public static let member = "SourceId" }
        public struct _TagsEncoding: ArrayCoderProperties { public static let member = "Tag" }

        /// The Amazon Web Services account associated with the Amazon Redshift event notification subscription.
        public let customerAwsId: String?
        /// The name of the Amazon Redshift event notification subscription.
        public let custSubscriptionId: String?
        /// A boolean value indicating whether the subscription is enabled; true indicates that the subscription is enabled.
        public let enabled: Bool?
        /// The list of Amazon Redshift event categories specified in the event notification subscription. Values: Configuration, Management, Monitoring, Security, Pending
        @OptionalCustomCoding<ArrayCoder<_EventCategoriesListEncoding, String>>
        public var eventCategoriesList: [String]?
        /// The event severity specified in the Amazon Redshift event notification subscription. Values: ERROR, INFO
        public let severity: String?
        /// The Amazon Resource Name (ARN) of the Amazon SNS topic used by the event notification subscription.
        public let snsTopicArn: String?
        /// A list of the sources that publish events to the Amazon Redshift event notification subscription.
        @OptionalCustomCoding<ArrayCoder<_SourceIdsListEncoding, String>>
        public var sourceIdsList: [String]?
        /// The source type of the events returned by the Amazon Redshift event notification, such as cluster, cluster-snapshot, cluster-parameter-group, cluster-security-group, or scheduled-action.
        public let sourceType: String?
        /// The status of the Amazon Redshift event notification subscription. Constraints:   Can be one of the following: active | no-permission | topic-not-exist   The status "no-permission" indicates that Amazon Redshift no longer has permission to post to the Amazon SNS topic. The status "topic-not-exist" indicates that the topic was deleted after the subscription was created.
        public let status: String?
        /// The date and time the Amazon Redshift event notification subscription was created.
        public let subscriptionCreationTime: Date?
        /// The list of tags for the event subscription.
        @OptionalCustomCoding<ArrayCoder<_TagsEncoding, Tag>>
        public var tags: [Tag]?

        @inlinable
        public init(customerAwsId: String? = nil, custSubscriptionId: String? = nil, enabled: Bool? = nil, eventCategoriesList: [String]? = nil, severity: String? = nil, snsTopicArn: String? = nil, sourceIdsList: [String]? = nil, sourceType: String? = nil, status: String? = nil, subscriptionCreationTime: Date? = nil, tags: [Tag]? = nil) {
            self.customerAwsId = customerAwsId
            self.custSubscriptionId = custSubscriptionId
            self.enabled = enabled
            self.eventCategoriesList = eventCategoriesList
            self.severity = severity
            self.snsTopicArn = snsTopicArn
            self.sourceIdsList = sourceIdsList
            self.sourceType = sourceType
            self.status = status
            self.subscriptionCreationTime = subscriptionCreationTime
            self.tags = tags
        }

        private enum CodingKeys: String, CodingKey {
            case customerAwsId = "CustomerAwsId"
            case custSubscriptionId = "CustSubscriptionId"
            case enabled = "Enabled"
            case eventCategoriesList = "EventCategoriesList"
            case severity = "Severity"
            case snsTopicArn = "SnsTopicArn"
            case sourceIdsList = "SourceIdsList"
            case sourceType = "SourceType"
            case status = "Status"
            case subscriptionCreationTime = "SubscriptionCreationTime"
            case tags = "Tags"
        }
    }

    public struct EventSubscriptionsMessage: AWSDecodableShape {
        public struct _EventSubscriptionsListEncoding: ArrayCoderProperties { public static let member = "EventSubscription" }

        /// A list of event subscriptions.
        @OptionalCustomCoding<ArrayCoder<_EventSubscriptionsListEncoding, EventSubscription>>
        public var eventSubscriptionsList: [EventSubscription]?
        /// A value that indicates the starting point for the next set of response records in a subsequent request. If a value is returned in a response, you can retrieve the next set of records by providing this returned marker value in the Marker parameter and retrying the command. If the Marker field is empty, all response records have been retrieved for the request.
        public let marker: String?

        @inlinable
        public init(eventSubscriptionsList: [EventSubscription]? = nil, marker: String? = nil) {
            self.eventSubscriptionsList = eventSubscriptionsList
            self.marker = marker
        }

        private enum CodingKeys: String, CodingKey {
            case eventSubscriptionsList = "EventSubscriptionsList"
            case marker = "Marker"
        }
    }

    public struct EventsMessage: AWSDecodableShape {
        public struct _EventsEncoding: ArrayCoderProperties { public static let member = "Event" }

        /// A list of Event instances.
        @OptionalCustomCoding<ArrayCoder<_EventsEncoding, Event>>
        public var events: [Event]?
        /// A value that indicates the starting point for the next set of response records in a subsequent request. If a value is returned in a response, you can retrieve the next set of records by providing this returned marker value in the Marker parameter and retrying the command. If the Marker field is empty, all response records have been retrieved for the request.
        public let marker: String?

        @inlinable
        public init(events: [Event]? = nil, marker: String? = nil) {
            self.events = events
            self.marker = marker
        }

        private enum CodingKeys: String, CodingKey {
            case events = "Events"
            case marker = "Marker"
        }
    }

    public struct FailoverPrimaryComputeInputMessage: AWSEncodableShape {
        /// The unique identifier of the cluster for which the primary compute unit will be failed over to another Availability Zone.
        public let clusterIdentifier: String?

        @inlinable
        public init(clusterIdentifier: String? = nil) {
            self.clusterIdentifier = clusterIdentifier
        }

        public func validate(name: String) throws {
            try self.validate(self.clusterIdentifier, name: "clusterIdentifier", parent: name, max: 2147483647)
        }

        private enum CodingKeys: String, CodingKey {
            case clusterIdentifier = "ClusterIdentifier"
        }
    }

    public struct FailoverPrimaryComputeResult: AWSDecodableShape {
        public let cluster: Cluster?

        @inlinable
        public init(cluster: Cluster? = nil) {
            self.cluster = cluster
        }

        private enum CodingKeys: String, CodingKey {
            case cluster = "Cluster"
        }
    }

    public struct GetClusterCredentialsMessage: AWSEncodableShape {
        public struct _DbGroupsEncoding: ArrayCoderProperties { public static let member = "DbGroup" }

        /// Create a database user with the name specified for the user named in DbUser if one does not exist.
        public let autoCreate: Bool?
        /// The unique identifier of the cluster that contains the database for which you are requesting credentials. This parameter is case sensitive.
        public let clusterIdentifier: String?
        /// The custom domain name for the cluster credentials.
        public let customDomainName: String?
        /// A list of the names of existing database groups that the user named in DbUser will join for the current session, in addition to any group memberships for an existing user. If not specified, a new user is added only to PUBLIC. Database group name constraints   Must be 1 to 64 alphanumeric characters or hyphens   Must contain only lowercase letters, numbers, underscore, plus sign, period (dot), at symbol (@), or hyphen.   First character must be a letter.   Must not contain a colon ( : ) or slash ( / ).    Cannot be a reserved word. A list of reserved words can be found in Reserved Words in the Amazon Redshift Database Developer Guide.
        @OptionalCustomCoding<ArrayCoder<_DbGroupsEncoding, String>>
        public var dbGroups: [String]?
        /// The name of a database that DbUser is authorized to log on to. If DbName is not specified, DbUser can log on to any existing database. Constraints:   Must be 1 to 64 alphanumeric characters or hyphens   Must contain uppercase or lowercase letters, numbers, underscore, plus sign, period (dot), at symbol (@), or hyphen.   First character must be a letter.   Must not contain a colon ( : ) or slash ( / ).    Cannot be a reserved word. A list of reserved words can be found in Reserved Words in the Amazon Redshift Database Developer Guide.
        public let dbName: String?
        /// The name of a database user. If a user name matching DbUser exists in the database, the temporary user credentials have the same permissions as the existing user. If DbUser doesn't exist in the database and Autocreate is True, a new user is created using the value for DbUser with PUBLIC permissions. If a database user matching the value for DbUser doesn't exist and Autocreate is False, then the command succeeds but the connection attempt will fail because the user doesn't exist in the database. For more information, see CREATE USER in the Amazon Redshift Database Developer Guide.  Constraints:   Must be 1 to 64 alphanumeric characters or hyphens. The user name can't be PUBLIC.   Must contain uppercase or lowercase letters, numbers, underscore, plus sign, period (dot), at symbol (@), or hyphen.   First character must be a letter.   Must not contain a colon ( : ) or slash ( / ).    Cannot be a reserved word. A list of reserved words can be found in Reserved Words in the Amazon Redshift Database Developer Guide.
        public let dbUser: String?
        /// The number of seconds until the returned temporary password expires. Constraint: minimum 900, maximum 3600. Default: 900
        public let durationSeconds: Int?

        @inlinable
        public init(autoCreate: Bool? = nil, clusterIdentifier: String? = nil, customDomainName: String? = nil, dbGroups: [String]? = nil, dbName: String? = nil, dbUser: String? = nil, durationSeconds: Int? = nil) {
            self.autoCreate = autoCreate
            self.clusterIdentifier = clusterIdentifier
            self.customDomainName = customDomainName
            self.dbGroups = dbGroups
            self.dbName = dbName
            self.dbUser = dbUser
            self.durationSeconds = durationSeconds
        }

        public func validate(name: String) throws {
            try self.validate(self.clusterIdentifier, name: "clusterIdentifier", parent: name, max: 2147483647)
            try self.validate(self.customDomainName, name: "customDomainName", parent: name, max: 2147483647)
            try self.dbGroups?.forEach {
                try validate($0, name: "dbGroups[]", parent: name, max: 2147483647)
            }
            try self.validate(self.dbName, name: "dbName", parent: name, max: 2147483647)
            try self.validate(self.dbUser, name: "dbUser", parent: name, max: 2147483647)
        }

        private enum CodingKeys: String, CodingKey {
            case autoCreate = "AutoCreate"
            case clusterIdentifier = "ClusterIdentifier"
            case customDomainName = "CustomDomainName"
            case dbGroups = "DbGroups"
            case dbName = "DbName"
            case dbUser = "DbUser"
            case durationSeconds = "DurationSeconds"
        }
    }

    public struct GetClusterCredentialsWithIAMMessage: AWSEncodableShape {
        /// The unique identifier of the cluster that contains the database for which you are requesting credentials.
        public let clusterIdentifier: String?
        /// The custom domain name for the IAM message cluster credentials.
        public let customDomainName: String?
        /// The name of the database for which you are requesting credentials. If the database name is specified, the IAM policy must allow access to the resource dbname for the specified database name. If the database name is not specified, access to all databases is allowed.
        public let dbName: String?
        /// The number of seconds until the returned temporary password expires. Range: 900-3600. Default: 900.
        public let durationSeconds: Int?

        @inlinable
        public init(clusterIdentifier: String? = nil, customDomainName: String? = nil, dbName: String? = nil, durationSeconds: Int? = nil) {
            self.clusterIdentifier = clusterIdentifier
            self.customDomainName = customDomainName
            self.dbName = dbName
            self.durationSeconds = durationSeconds
        }

        public func validate(name: String) throws {
            try self.validate(self.clusterIdentifier, name: "clusterIdentifier", parent: name, max: 2147483647)
            try self.validate(self.customDomainName, name: "customDomainName", parent: name, max: 2147483647)
            try self.validate(self.dbName, name: "dbName", parent: name, max: 2147483647)
        }

        private enum CodingKeys: String, CodingKey {
            case clusterIdentifier = "ClusterIdentifier"
            case customDomainName = "CustomDomainName"
            case dbName = "DbName"
            case durationSeconds = "DurationSeconds"
        }
    }

    public struct GetReservedNodeExchangeConfigurationOptionsInputMessage: AWSEncodableShape {
        /// The action type of the reserved-node configuration. The action type can be an exchange initiated from either a snapshot or a resize.
        public let actionType: ReservedNodeExchangeActionType?
        /// The identifier for the cluster that is the source for a reserved-node exchange.
        public let clusterIdentifier: String?
        /// An optional pagination token provided by a previous GetReservedNodeExchangeConfigurationOptions request. If this  parameter is specified, the response includes only records beyond the marker, up to the value  specified by the MaxRecords parameter. You can retrieve the next set of response records by providing the returned marker value in the Marker parameter and retrying the request.
        public let marker: String?
        /// The maximum number of response records to return in each call. If the number of remaining response records exceeds the specified MaxRecords value, a value is returned in a Marker field of the response. You can retrieve the next set of records by retrying the command with the returned marker value.
        public let maxRecords: Int?
        /// The identifier for the snapshot that is the source for the reserved-node exchange.
        public let snapshotIdentifier: String?

        @inlinable
        public init(actionType: ReservedNodeExchangeActionType? = nil, clusterIdentifier: String? = nil, marker: String? = nil, maxRecords: Int? = nil, snapshotIdentifier: String? = nil) {
            self.actionType = actionType
            self.clusterIdentifier = clusterIdentifier
            self.marker = marker
            self.maxRecords = maxRecords
            self.snapshotIdentifier = snapshotIdentifier
        }

        public func validate(name: String) throws {
            try self.validate(self.clusterIdentifier, name: "clusterIdentifier", parent: name, max: 2147483647)
            try self.validate(self.marker, name: "marker", parent: name, max: 2147483647)
            try self.validate(self.snapshotIdentifier, name: "snapshotIdentifier", parent: name, max: 2147483647)
        }

        private enum CodingKeys: String, CodingKey {
            case actionType = "ActionType"
            case clusterIdentifier = "ClusterIdentifier"
            case marker = "Marker"
            case maxRecords = "MaxRecords"
            case snapshotIdentifier = "SnapshotIdentifier"
        }
    }

    public struct GetReservedNodeExchangeConfigurationOptionsOutputMessage: AWSDecodableShape {
        public struct _ReservedNodeConfigurationOptionListEncoding: ArrayCoderProperties { public static let member = "ReservedNodeConfigurationOption" }

        /// A pagination token provided by a previous GetReservedNodeExchangeConfigurationOptions request.
        public let marker: String?
        /// the configuration options for the reserved-node exchange. These options include information about the source reserved node and target reserved node. Details include the node type, the price, the node count, and the offering type.
        @OptionalCustomCoding<ArrayCoder<_ReservedNodeConfigurationOptionListEncoding, ReservedNodeConfigurationOption>>
        public var reservedNodeConfigurationOptionList: [ReservedNodeConfigurationOption]?

        @inlinable
        public init(marker: String? = nil, reservedNodeConfigurationOptionList: [ReservedNodeConfigurationOption]? = nil) {
            self.marker = marker
            self.reservedNodeConfigurationOptionList = reservedNodeConfigurationOptionList
        }

        private enum CodingKeys: String, CodingKey {
            case marker = "Marker"
            case reservedNodeConfigurationOptionList = "ReservedNodeConfigurationOptionList"
        }
    }

    public struct GetReservedNodeExchangeOfferingsInputMessage: AWSEncodableShape {
        /// A value that indicates the starting point for the next set of ReservedNodeOfferings.
        public let marker: String?
        /// An integer setting the maximum number of ReservedNodeOfferings to retrieve.
        public let maxRecords: Int?
        /// A string representing the node identifier for the DC1 Reserved Node to be exchanged.
        public let reservedNodeId: String?

        @inlinable
        public init(marker: String? = nil, maxRecords: Int? = nil, reservedNodeId: String? = nil) {
            self.marker = marker
            self.maxRecords = maxRecords
            self.reservedNodeId = reservedNodeId
        }

        public func validate(name: String) throws {
            try self.validate(self.marker, name: "marker", parent: name, max: 2147483647)
            try self.validate(self.reservedNodeId, name: "reservedNodeId", parent: name, max: 2147483647)
        }

        private enum CodingKeys: String, CodingKey {
            case marker = "Marker"
            case maxRecords = "MaxRecords"
            case reservedNodeId = "ReservedNodeId"
        }
    }

    public struct GetReservedNodeExchangeOfferingsOutputMessage: AWSDecodableShape {
        public struct _ReservedNodeOfferingsEncoding: ArrayCoderProperties { public static let member = "ReservedNodeOffering" }

        /// An optional parameter that specifies the starting point for returning a set of response records. When the results of a GetReservedNodeExchangeOfferings request exceed the value specified in MaxRecords, Amazon Redshift returns a value in the marker field of the response. You can retrieve the next set of response records by providing the returned marker value in the marker parameter and retrying the request.
        public let marker: String?
        /// Returns an array of ReservedNodeOffering objects.
        @OptionalCustomCoding<ArrayCoder<_ReservedNodeOfferingsEncoding, ReservedNodeOffering>>
        public var reservedNodeOfferings: [ReservedNodeOffering]?

        @inlinable
        public init(marker: String? = nil, reservedNodeOfferings: [ReservedNodeOffering]? = nil) {
            self.marker = marker
            self.reservedNodeOfferings = reservedNodeOfferings
        }

        private enum CodingKeys: String, CodingKey {
            case marker = "Marker"
            case reservedNodeOfferings = "ReservedNodeOfferings"
        }
    }

    public struct GetResourcePolicyMessage: AWSEncodableShape {
        /// The Amazon Resource Name (ARN) of the resource of which its resource policy is fetched.
        public let resourceArn: String?

        @inlinable
        public init(resourceArn: String? = nil) {
            self.resourceArn = resourceArn
        }

        public func validate(name: String) throws {
            try self.validate(self.resourceArn, name: "resourceArn", parent: name, max: 2147483647)
        }

        private enum CodingKeys: String, CodingKey {
            case resourceArn = "ResourceArn"
        }
    }

    public struct GetResourcePolicyResult: AWSDecodableShape {
        /// The content of the resource policy.
        public let resourcePolicy: ResourcePolicy?

        @inlinable
        public init(resourcePolicy: ResourcePolicy? = nil) {
            self.resourcePolicy = resourcePolicy
        }

        private enum CodingKeys: String, CodingKey {
            case resourcePolicy = "ResourcePolicy"
        }
    }

    public struct HsmClientCertificate: AWSDecodableShape {
        public struct _TagsEncoding: ArrayCoderProperties { public static let member = "Tag" }

        /// The identifier of the HSM client certificate.
        public let hsmClientCertificateIdentifier: String?
        /// The public key that the Amazon Redshift cluster will use to connect to the HSM. You must register the public key in the HSM.
        public let hsmClientCertificatePublicKey: String?
        /// The list of tags for the HSM client certificate.
        @OptionalCustomCoding<ArrayCoder<_TagsEncoding, Tag>>
        public var tags: [Tag]?

        @inlinable
        public init(hsmClientCertificateIdentifier: String? = nil, hsmClientCertificatePublicKey: String? = nil, tags: [Tag]? = nil) {
            self.hsmClientCertificateIdentifier = hsmClientCertificateIdentifier
            self.hsmClientCertificatePublicKey = hsmClientCertificatePublicKey
            self.tags = tags
        }

        private enum CodingKeys: String, CodingKey {
            case hsmClientCertificateIdentifier = "HsmClientCertificateIdentifier"
            case hsmClientCertificatePublicKey = "HsmClientCertificatePublicKey"
            case tags = "Tags"
        }
    }

    public struct HsmClientCertificateMessage: AWSDecodableShape {
        public struct _HsmClientCertificatesEncoding: ArrayCoderProperties { public static let member = "HsmClientCertificate" }

        /// A list of the identifiers for one or more HSM client certificates used by Amazon Redshift clusters to store and retrieve database encryption keys in an HSM.
        @OptionalCustomCoding<ArrayCoder<_HsmClientCertificatesEncoding, HsmClientCertificate>>
        public var hsmClientCertificates: [HsmClientCertificate]?
        /// A value that indicates the starting point for the next set of response records in a subsequent request. If a value is returned in a response, you can retrieve the next set of records by providing this returned marker value in the Marker parameter and retrying the command. If the Marker field is empty, all response records have been retrieved for the request.
        public let marker: String?

        @inlinable
        public init(hsmClientCertificates: [HsmClientCertificate]? = nil, marker: String? = nil) {
            self.hsmClientCertificates = hsmClientCertificates
            self.marker = marker
        }

        private enum CodingKeys: String, CodingKey {
            case hsmClientCertificates = "HsmClientCertificates"
            case marker = "Marker"
        }
    }

    public struct HsmConfiguration: AWSDecodableShape {
        public struct _TagsEncoding: ArrayCoderProperties { public static let member = "Tag" }

        /// A text description of the HSM configuration.
        public let description: String?
        /// The name of the Amazon Redshift HSM configuration.
        public let hsmConfigurationIdentifier: String?
        /// The IP address that the Amazon Redshift cluster must use to access the HSM.
        public let hsmIpAddress: String?
        /// The name of the partition in the HSM where the Amazon Redshift clusters will store their database encryption keys.
        public let hsmPartitionName: String?
        /// The list of tags for the HSM configuration.
        @OptionalCustomCoding<ArrayCoder<_TagsEncoding, Tag>>
        public var tags: [Tag]?

        @inlinable
        public init(description: String? = nil, hsmConfigurationIdentifier: String? = nil, hsmIpAddress: String? = nil, hsmPartitionName: String? = nil, tags: [Tag]? = nil) {
            self.description = description
            self.hsmConfigurationIdentifier = hsmConfigurationIdentifier
            self.hsmIpAddress = hsmIpAddress
            self.hsmPartitionName = hsmPartitionName
            self.tags = tags
        }

        private enum CodingKeys: String, CodingKey {
            case description = "Description"
            case hsmConfigurationIdentifier = "HsmConfigurationIdentifier"
            case hsmIpAddress = "HsmIpAddress"
            case hsmPartitionName = "HsmPartitionName"
            case tags = "Tags"
        }
    }

    public struct HsmConfigurationMessage: AWSDecodableShape {
        public struct _HsmConfigurationsEncoding: ArrayCoderProperties { public static let member = "HsmConfiguration" }

        /// A list of HsmConfiguration objects.
        @OptionalCustomCoding<ArrayCoder<_HsmConfigurationsEncoding, HsmConfiguration>>
        public var hsmConfigurations: [HsmConfiguration]?
        /// A value that indicates the starting point for the next set of response records in a subsequent request. If a value is returned in a response, you can retrieve the next set of records by providing this returned marker value in the Marker parameter and retrying the command. If the Marker field is empty, all response records have been retrieved for the request.
        public let marker: String?

        @inlinable
        public init(hsmConfigurations: [HsmConfiguration]? = nil, marker: String? = nil) {
            self.hsmConfigurations = hsmConfigurations
            self.marker = marker
        }

        private enum CodingKeys: String, CodingKey {
            case hsmConfigurations = "HsmConfigurations"
            case marker = "Marker"
        }
    }

    public struct HsmStatus: AWSDecodableShape {
        /// Specifies the name of the HSM client certificate the Amazon Redshift cluster uses to retrieve the data encryption keys stored in an HSM.
        public let hsmClientCertificateIdentifier: String?
        /// Specifies the name of the HSM configuration that contains the information the Amazon Redshift cluster can use to retrieve and store keys in an HSM.
        public let hsmConfigurationIdentifier: String?
        /// Reports whether the Amazon Redshift cluster has finished applying any HSM settings changes specified in a modify cluster command. Values: active, applying
        public let status: String?

        @inlinable
        public init(hsmClientCertificateIdentifier: String? = nil, hsmConfigurationIdentifier: String? = nil, status: String? = nil) {
            self.hsmClientCertificateIdentifier = hsmClientCertificateIdentifier
            self.hsmConfigurationIdentifier = hsmConfigurationIdentifier
            self.status = status
        }

        private enum CodingKeys: String, CodingKey {
            case hsmClientCertificateIdentifier = "HsmClientCertificateIdentifier"
            case hsmConfigurationIdentifier = "HsmConfigurationIdentifier"
            case status = "Status"
        }
    }

    public struct IPRange: AWSDecodableShape {
        public struct _TagsEncoding: ArrayCoderProperties { public static let member = "Tag" }

        /// The IP range in Classless Inter-Domain Routing (CIDR) notation.
        public let cidrip: String?
        /// The status of the IP range, for example, "authorized".
        public let status: String?
        /// The list of tags for the IP range.
        @OptionalCustomCoding<ArrayCoder<_TagsEncoding, Tag>>
        public var tags: [Tag]?

        @inlinable
        public init(cidrip: String? = nil, status: String? = nil, tags: [Tag]? = nil) {
            self.cidrip = cidrip
            self.status = status
            self.tags = tags
        }

        private enum CodingKeys: String, CodingKey {
            case cidrip = "CIDRIP"
            case status = "Status"
            case tags = "Tags"
        }
    }

    public struct InboundIntegration: AWSDecodableShape {
        public struct _ErrorsEncoding: ArrayCoderProperties { public static let member = "IntegrationError" }

        /// The creation time of an inbound integration.
        public let createTime: Date?
        /// The outstanding errors of an inbound  integration. Each item is an "IntegrationError". This is null if there is no error.
        @OptionalCustomCoding<ArrayCoder<_ErrorsEncoding, IntegrationError>>
        public var errors: [IntegrationError]?
        /// The Amazon Resource Name (ARN) of an inbound integration.
        public let integrationArn: String?
        /// The Amazon Resource Name (ARN) of the source of an inbound integration.
        public let sourceArn: String?
        /// The status of an inbound integration.
        public let status: ZeroETLIntegrationStatus?
        /// The Amazon Resource Name (ARN) of the target of an inbound integration.
        public let targetArn: String?

        @inlinable
        public init(createTime: Date? = nil, errors: [IntegrationError]? = nil, integrationArn: String? = nil, sourceArn: String? = nil, status: ZeroETLIntegrationStatus? = nil, targetArn: String? = nil) {
            self.createTime = createTime
            self.errors = errors
            self.integrationArn = integrationArn
            self.sourceArn = sourceArn
            self.status = status
            self.targetArn = targetArn
        }

        private enum CodingKeys: String, CodingKey {
            case createTime = "CreateTime"
            case errors = "Errors"
            case integrationArn = "IntegrationArn"
            case sourceArn = "SourceArn"
            case status = "Status"
            case targetArn = "TargetArn"
        }
    }

    public struct InboundIntegrationsMessage: AWSDecodableShape {
        public struct _InboundIntegrationsEncoding: ArrayCoderProperties { public static let member = "InboundIntegration" }

        /// A list of InboundIntegration instances.
        @OptionalCustomCoding<ArrayCoder<_InboundIntegrationsEncoding, InboundIntegration>>
        public var inboundIntegrations: [InboundIntegration]?
        /// A value that indicates the starting point for the next set of response records in a subsequent request. If a value is returned in a response, you can retrieve the next set of records by providing this returned marker value in the Marker parameter and retrying the command. If the Marker field is empty, all response records have been retrieved for the request.
        public let marker: String?

        @inlinable
        public init(inboundIntegrations: [InboundIntegration]? = nil, marker: String? = nil) {
            self.inboundIntegrations = inboundIntegrations
            self.marker = marker
        }

        private enum CodingKeys: String, CodingKey {
            case inboundIntegrations = "InboundIntegrations"
            case marker = "Marker"
        }
    }

    public struct Integration: AWSDecodableShape {
        public struct _ErrorsEncoding: ArrayCoderProperties { public static let member = "IntegrationError" }
        public struct _TagsEncoding: ArrayCoderProperties { public static let member = "Tag" }

        /// The encryption context for the integration. For more information,  see Encryption context in the Amazon Web Services Key Management Service Developer Guide.
        @OptionalCustomCoding<StandardDictionaryCoder<String, String>>
        public var additionalEncryptionContext: [String: String]?
        /// The time (UTC) when the integration was created.
        public let createTime: Date?
        /// The description of the integration.
        public let description: String?
        /// Any errors associated with the integration.
        @OptionalCustomCoding<ArrayCoder<_ErrorsEncoding, IntegrationError>>
        public var errors: [IntegrationError]?
        /// The Amazon Resource Name (ARN) of the integration.
        public let integrationArn: String?
        /// The name of the integration.
        public let integrationName: String?
        /// The Key Management Service (KMS) key identifier for the key used to encrypt the integration.
        public let kmsKeyId: String?
        /// The Amazon Resource Name (ARN) of the database used as the source for replication.
        public let sourceArn: String?
        /// The current status of the integration.
        public let status: ZeroETLIntegrationStatus?
        /// The list of tags associated with the integration.
        @OptionalCustomCoding<ArrayCoder<_TagsEncoding, Tag>>
        public var tags: [Tag]?
        /// The Amazon Resource Name (ARN) of the Amazon Redshift data warehouse to use as the target for replication.
        public let targetArn: String?

        @inlinable
        public init(additionalEncryptionContext: [String: String]? = nil, createTime: Date? = nil, description: String? = nil, errors: [IntegrationError]? = nil, integrationArn: String? = nil, integrationName: String? = nil, kmsKeyId: String? = nil, sourceArn: String? = nil, status: ZeroETLIntegrationStatus? = nil, tags: [Tag]? = nil, targetArn: String? = nil) {
            self.additionalEncryptionContext = additionalEncryptionContext
            self.createTime = createTime
            self.description = description
            self.errors = errors
            self.integrationArn = integrationArn
            self.integrationName = integrationName
            self.kmsKeyId = kmsKeyId
            self.sourceArn = sourceArn
            self.status = status
            self.tags = tags
            self.targetArn = targetArn
        }

        private enum CodingKeys: String, CodingKey {
            case additionalEncryptionContext = "AdditionalEncryptionContext"
            case createTime = "CreateTime"
            case description = "Description"
            case errors = "Errors"
            case integrationArn = "IntegrationArn"
            case integrationName = "IntegrationName"
            case kmsKeyId = "KMSKeyId"
            case sourceArn = "SourceArn"
            case status = "Status"
            case tags = "Tags"
            case targetArn = "TargetArn"
        }
    }

    public struct IntegrationError: AWSDecodableShape {
        /// The error code of an inbound integration error.
        public let errorCode: String?
        /// The error message of an inbound integration error.
        public let errorMessage: String?

        @inlinable
        public init(errorCode: String? = nil, errorMessage: String? = nil) {
            self.errorCode = errorCode
            self.errorMessage = errorMessage
        }

        private enum CodingKeys: String, CodingKey {
            case errorCode = "ErrorCode"
            case errorMessage = "ErrorMessage"
        }
    }

    public struct IntegrationsMessage: AWSDecodableShape {
        public struct _IntegrationsEncoding: ArrayCoderProperties { public static let member = "Integration" }

        /// List of integrations that are described.
        @OptionalCustomCoding<ArrayCoder<_IntegrationsEncoding, Integration>>
        public var integrations: [Integration]?
        /// A value that indicates the starting point for the next set of response records in a subsequent request.  If a value is returned in a response, you can retrieve the next set of records by providing this returned marker value in the Marker parameter and retrying the command.  If the Marker field is empty, all response records have been retrieved for the request.
        public let marker: String?

        @inlinable
        public init(integrations: [Integration]? = nil, marker: String? = nil) {
            self.integrations = integrations
            self.marker = marker
        }

        private enum CodingKeys: String, CodingKey {
            case integrations = "Integrations"
            case marker = "Marker"
        }
    }

    public struct LakeFormationQuery: AWSEncodableShape & AWSDecodableShape {
        /// Determines whether the query scope is enabled or disabled.
        public let authorization: ServiceAuthorization?

        @inlinable
        public init(authorization: ServiceAuthorization? = nil) {
            self.authorization = authorization
        }

        private enum CodingKeys: String, CodingKey {
            case authorization = "Authorization"
        }
    }

    public struct ListRecommendationsMessage: AWSEncodableShape {
        /// The unique identifier of the Amazon Redshift cluster for which the list of Advisor recommendations is returned.  If the neither the cluster identifier and the cluster namespace ARN parameters are specified, then recommendations for all clusters in the account are returned.
        public let clusterIdentifier: String?
        /// A value that indicates the starting point for the next set of response records in a subsequent request. If a  value is returned in a response, you can retrieve the next set of records by providing this returned marker value in the Marker parameter and retrying the command. If the Marker field is empty, all response records have been retrieved for the request.
        public let marker: String?
        /// The maximum number of response records to return in each call. If the number of remaining response records  exceeds the specified MaxRecords value, a value is returned in a marker field of the response. You can retrieve  the next set of records by retrying the command with the returned marker value.
        public let maxRecords: Int?
        /// The Amazon Redshift cluster namespace Amazon Resource Name (ARN) for which the list of Advisor recommendations is returned. If the neither the cluster identifier and the cluster namespace ARN parameters are specified, then recommendations for all clusters in the account are returned.
        public let namespaceArn: String?

        @inlinable
        public init(clusterIdentifier: String? = nil, marker: String? = nil, maxRecords: Int? = nil, namespaceArn: String? = nil) {
            self.clusterIdentifier = clusterIdentifier
            self.marker = marker
            self.maxRecords = maxRecords
            self.namespaceArn = namespaceArn
        }

        public func validate(name: String) throws {
            try self.validate(self.clusterIdentifier, name: "clusterIdentifier", parent: name, max: 2147483647)
            try self.validate(self.marker, name: "marker", parent: name, max: 2147483647)
            try self.validate(self.namespaceArn, name: "namespaceArn", parent: name, max: 2147483647)
        }

        private enum CodingKeys: String, CodingKey {
            case clusterIdentifier = "ClusterIdentifier"
            case marker = "Marker"
            case maxRecords = "MaxRecords"
            case namespaceArn = "NamespaceArn"
        }
    }

    public struct ListRecommendationsResult: AWSDecodableShape {
        public struct _RecommendationsEncoding: ArrayCoderProperties { public static let member = "Recommendation" }

        /// A value that indicates the starting point for the next set of response records in a subsequent  request. If a value is returned in a response, you can retrieve the next set of records by providing this returned marker value in the Marker parameter and retrying the command. If the Marker field is empty, all response records have been retrieved for the request.
        public let marker: String?
        /// The Advisor recommendations for action on the Amazon Redshift cluster.
        @OptionalCustomCoding<ArrayCoder<_RecommendationsEncoding, Recommendation>>
        public var recommendations: [Recommendation]?

        @inlinable
        public init(marker: String? = nil, recommendations: [Recommendation]? = nil) {
            self.marker = marker
            self.recommendations = recommendations
        }

        private enum CodingKeys: String, CodingKey {
            case marker = "Marker"
            case recommendations = "Recommendations"
        }
    }

    public struct LoggingStatus: AWSDecodableShape {
        /// The name of the S3 bucket where the log files are stored.
        public let bucketName: String?
        /// The message indicating that logs failed to be delivered.
        public let lastFailureMessage: String?
        /// The last time when logs failed to be delivered.
        public let lastFailureTime: Date?
        /// The last time that logs were delivered.
        public let lastSuccessfulDeliveryTime: Date?
        /// The log destination type. An enum with possible values of s3 and cloudwatch.
        public let logDestinationType: LogDestinationType?
        /// The collection of exported log types. Possible values are connectionlog, useractivitylog, and  userlog.
        @OptionalCustomCoding<StandardArrayCoder<String>>
        public var logExports: [String]?
        ///  true if logging is on, false if logging is off.
        public let loggingEnabled: Bool?
        /// The prefix applied to the log file names.
        public let s3KeyPrefix: String?

        @inlinable
        public init(bucketName: String? = nil, lastFailureMessage: String? = nil, lastFailureTime: Date? = nil, lastSuccessfulDeliveryTime: Date? = nil, logDestinationType: LogDestinationType? = nil, logExports: [String]? = nil, loggingEnabled: Bool? = nil, s3KeyPrefix: String? = nil) {
            self.bucketName = bucketName
            self.lastFailureMessage = lastFailureMessage
            self.lastFailureTime = lastFailureTime
            self.lastSuccessfulDeliveryTime = lastSuccessfulDeliveryTime
            self.logDestinationType = logDestinationType
            self.logExports = logExports
            self.loggingEnabled = loggingEnabled
            self.s3KeyPrefix = s3KeyPrefix
        }

        private enum CodingKeys: String, CodingKey {
            case bucketName = "BucketName"
            case lastFailureMessage = "LastFailureMessage"
            case lastFailureTime = "LastFailureTime"
            case lastSuccessfulDeliveryTime = "LastSuccessfulDeliveryTime"
            case logDestinationType = "LogDestinationType"
            case logExports = "LogExports"
            case loggingEnabled = "LoggingEnabled"
            case s3KeyPrefix = "S3KeyPrefix"
        }
    }

    public struct MaintenanceTrack: AWSDecodableShape {
        public struct _UpdateTargetsEncoding: ArrayCoderProperties { public static let member = "UpdateTarget" }

        /// The version number for the cluster release.
        public let databaseVersion: String?
        /// The name of the maintenance track. Possible values are current and trailing.
        public let maintenanceTrackName: String?
        /// An array of UpdateTarget objects to update with the maintenance track.
        @OptionalCustomCoding<ArrayCoder<_UpdateTargetsEncoding, UpdateTarget>>
        public var updateTargets: [UpdateTarget]?

        @inlinable
        public init(databaseVersion: String? = nil, maintenanceTrackName: String? = nil, updateTargets: [UpdateTarget]? = nil) {
            self.databaseVersion = databaseVersion
            self.maintenanceTrackName = maintenanceTrackName
            self.updateTargets = updateTargets
        }

        private enum CodingKeys: String, CodingKey {
            case databaseVersion = "DatabaseVersion"
            case maintenanceTrackName = "MaintenanceTrackName"
            case updateTargets = "UpdateTargets"
        }
    }

    public struct ModifyAquaInputMessage: AWSEncodableShape {
        /// This parameter is retired. Amazon Redshift automatically  determines whether to use AQUA (Advanced Query Accelerator).
        public let aquaConfigurationStatus: AquaConfigurationStatus?
        /// The identifier of the cluster to be modified.
        public let clusterIdentifier: String?

        @inlinable
        public init(aquaConfigurationStatus: AquaConfigurationStatus? = nil, clusterIdentifier: String? = nil) {
            self.aquaConfigurationStatus = aquaConfigurationStatus
            self.clusterIdentifier = clusterIdentifier
        }

        public func validate(name: String) throws {
            try self.validate(self.clusterIdentifier, name: "clusterIdentifier", parent: name, max: 2147483647)
        }

        private enum CodingKeys: String, CodingKey {
            case aquaConfigurationStatus = "AquaConfigurationStatus"
            case clusterIdentifier = "ClusterIdentifier"
        }
    }

    public struct ModifyAquaOutputMessage: AWSDecodableShape {
        /// This parameter is retired. Amazon Redshift automatically determines whether to use AQUA (Advanced Query Accelerator).
        public let aquaConfiguration: AquaConfiguration?

        @inlinable
        public init(aquaConfiguration: AquaConfiguration? = nil) {
            self.aquaConfiguration = aquaConfiguration
        }

        private enum CodingKeys: String, CodingKey {
            case aquaConfiguration = "AquaConfiguration"
        }
    }

    public struct ModifyAuthenticationProfileMessage: AWSEncodableShape {
        /// The new content of the authentication profile in JSON format. The maximum length of the JSON string is determined by a quota for your account.
        public let authenticationProfileContent: String?
        /// The name of the authentication profile to replace.
        public let authenticationProfileName: String?

        @inlinable
        public init(authenticationProfileContent: String? = nil, authenticationProfileName: String? = nil) {
            self.authenticationProfileContent = authenticationProfileContent
            self.authenticationProfileName = authenticationProfileName
        }

        public func validate(name: String) throws {
            try self.validate(self.authenticationProfileContent, name: "authenticationProfileContent", parent: name, max: 2147483647)
            try self.validate(self.authenticationProfileName, name: "authenticationProfileName", parent: name, max: 63)
            try self.validate(self.authenticationProfileName, name: "authenticationProfileName", parent: name, pattern: "^[a-zA-Z0-9\\-]+$")
        }

        private enum CodingKeys: String, CodingKey {
            case authenticationProfileContent = "AuthenticationProfileContent"
            case authenticationProfileName = "AuthenticationProfileName"
        }
    }

    public struct ModifyAuthenticationProfileResult: AWSDecodableShape {
        /// The updated content of the authentication profile in JSON format.
        public let authenticationProfileContent: String?
        /// The name of the authentication profile that was replaced.
        public let authenticationProfileName: String?

        @inlinable
        public init(authenticationProfileContent: String? = nil, authenticationProfileName: String? = nil) {
            self.authenticationProfileContent = authenticationProfileContent
            self.authenticationProfileName = authenticationProfileName
        }

        private enum CodingKeys: String, CodingKey {
            case authenticationProfileContent = "AuthenticationProfileContent"
            case authenticationProfileName = "AuthenticationProfileName"
        }
    }

    public struct ModifyClusterDbRevisionMessage: AWSEncodableShape {
        /// The unique identifier of a cluster whose database revision you want to modify.  Example: examplecluster
        public let clusterIdentifier: String?
        /// The identifier of the database revision. You can retrieve this value from the response to the DescribeClusterDbRevisions request.
        public let revisionTarget: String?

        @inlinable
        public init(clusterIdentifier: String? = nil, revisionTarget: String? = nil) {
            self.clusterIdentifier = clusterIdentifier
            self.revisionTarget = revisionTarget
        }

        public func validate(name: String) throws {
            try self.validate(self.clusterIdentifier, name: "clusterIdentifier", parent: name, max: 2147483647)
            try self.validate(self.revisionTarget, name: "revisionTarget", parent: name, max: 2147483647)
        }

        private enum CodingKeys: String, CodingKey {
            case clusterIdentifier = "ClusterIdentifier"
            case revisionTarget = "RevisionTarget"
        }
    }

    public struct ModifyClusterDbRevisionResult: AWSDecodableShape {
        public let cluster: Cluster?

        @inlinable
        public init(cluster: Cluster? = nil) {
            self.cluster = cluster
        }

        private enum CodingKeys: String, CodingKey {
            case cluster = "Cluster"
        }
    }

    public struct ModifyClusterIamRolesMessage: AWSEncodableShape {
        public struct _AddIamRolesEncoding: ArrayCoderProperties { public static let member = "IamRoleArn" }
        public struct _RemoveIamRolesEncoding: ArrayCoderProperties { public static let member = "IamRoleArn" }

        /// Zero or more IAM roles to associate with the cluster. The roles must be in their Amazon Resource Name (ARN) format.
        @OptionalCustomCoding<ArrayCoder<_AddIamRolesEncoding, String>>
        public var addIamRoles: [String]?
        /// The unique identifier of the cluster for which you want to associate or disassociate IAM roles.
        public let clusterIdentifier: String?
        /// The Amazon Resource Name (ARN) for the IAM role that was set as default for the cluster when the cluster was last modified.
        public let defaultIamRoleArn: String?
        /// Zero or more IAM roles in ARN format to disassociate from the cluster.
        @OptionalCustomCoding<ArrayCoder<_RemoveIamRolesEncoding, String>>
        public var removeIamRoles: [String]?

        @inlinable
        public init(addIamRoles: [String]? = nil, clusterIdentifier: String? = nil, defaultIamRoleArn: String? = nil, removeIamRoles: [String]? = nil) {
            self.addIamRoles = addIamRoles
            self.clusterIdentifier = clusterIdentifier
            self.defaultIamRoleArn = defaultIamRoleArn
            self.removeIamRoles = removeIamRoles
        }

        public func validate(name: String) throws {
            try self.addIamRoles?.forEach {
                try validate($0, name: "addIamRoles[]", parent: name, max: 2147483647)
            }
            try self.validate(self.clusterIdentifier, name: "clusterIdentifier", parent: name, max: 2147483647)
            try self.validate(self.defaultIamRoleArn, name: "defaultIamRoleArn", parent: name, max: 2147483647)
            try self.removeIamRoles?.forEach {
                try validate($0, name: "removeIamRoles[]", parent: name, max: 2147483647)
            }
        }

        private enum CodingKeys: String, CodingKey {
            case addIamRoles = "AddIamRoles"
            case clusterIdentifier = "ClusterIdentifier"
            case defaultIamRoleArn = "DefaultIamRoleArn"
            case removeIamRoles = "RemoveIamRoles"
        }
    }

    public struct ModifyClusterIamRolesResult: AWSDecodableShape {
        public let cluster: Cluster?

        @inlinable
        public init(cluster: Cluster? = nil) {
            self.cluster = cluster
        }

        private enum CodingKeys: String, CodingKey {
            case cluster = "Cluster"
        }
    }

    public struct ModifyClusterMaintenanceMessage: AWSEncodableShape {
        /// A unique identifier for the cluster.
        public let clusterIdentifier: String?
        /// A boolean indicating whether to enable the deferred maintenance window.
        public let deferMaintenance: Bool?
        /// An integer indicating the duration of the maintenance window in days. If you specify a duration, you can't specify an end time. The duration must be 45 days or less.
        public let deferMaintenanceDuration: Int?
        /// A timestamp indicating end time for the deferred maintenance window. If you specify an end time, you can't specify a duration.
        public let deferMaintenanceEndTime: Date?
        /// A unique identifier for the deferred maintenance window.
        public let deferMaintenanceIdentifier: String?
        /// A timestamp indicating the start time for the deferred maintenance window.
        public let deferMaintenanceStartTime: Date?

        @inlinable
        public init(clusterIdentifier: String? = nil, deferMaintenance: Bool? = nil, deferMaintenanceDuration: Int? = nil, deferMaintenanceEndTime: Date? = nil, deferMaintenanceIdentifier: String? = nil, deferMaintenanceStartTime: Date? = nil) {
            self.clusterIdentifier = clusterIdentifier
            self.deferMaintenance = deferMaintenance
            self.deferMaintenanceDuration = deferMaintenanceDuration
            self.deferMaintenanceEndTime = deferMaintenanceEndTime
            self.deferMaintenanceIdentifier = deferMaintenanceIdentifier
            self.deferMaintenanceStartTime = deferMaintenanceStartTime
        }

        public func validate(name: String) throws {
            try self.validate(self.clusterIdentifier, name: "clusterIdentifier", parent: name, max: 2147483647)
            try self.validate(self.deferMaintenanceIdentifier, name: "deferMaintenanceIdentifier", parent: name, max: 2147483647)
        }

        private enum CodingKeys: String, CodingKey {
            case clusterIdentifier = "ClusterIdentifier"
            case deferMaintenance = "DeferMaintenance"
            case deferMaintenanceDuration = "DeferMaintenanceDuration"
            case deferMaintenanceEndTime = "DeferMaintenanceEndTime"
            case deferMaintenanceIdentifier = "DeferMaintenanceIdentifier"
            case deferMaintenanceStartTime = "DeferMaintenanceStartTime"
        }
    }

    public struct ModifyClusterMaintenanceResult: AWSDecodableShape {
        public let cluster: Cluster?

        @inlinable
        public init(cluster: Cluster? = nil) {
            self.cluster = cluster
        }

        private enum CodingKeys: String, CodingKey {
            case cluster = "Cluster"
        }
    }

    public struct ModifyClusterMessage: AWSEncodableShape {
        public struct _ClusterSecurityGroupsEncoding: ArrayCoderProperties { public static let member = "ClusterSecurityGroupName" }
        public struct _VpcSecurityGroupIdsEncoding: ArrayCoderProperties { public static let member = "VpcSecurityGroupId" }

        /// If true, major version upgrades will be applied automatically to the cluster during the maintenance window.  Default: false
        public let allowVersionUpgrade: Bool?
        /// The number of days that automated snapshots are retained. If the value is 0, automated snapshots are disabled. Even if automated snapshots are disabled, you can still create manual snapshots when you want with CreateClusterSnapshot.  If you decrease the automated snapshot retention period from its current value, existing automated snapshots that fall outside of the new retention period will be immediately deleted. You can't disable automated snapshots for RA3 node types. Set the automated retention period from 1-35 days. Default: Uses existing setting. Constraints: Must be a value from 0 to 35.
        public let automatedSnapshotRetentionPeriod: Int?
        /// The option to initiate relocation for an Amazon Redshift cluster to the target Availability Zone.
        public let availabilityZone: String?
        /// The option to enable relocation for an Amazon Redshift cluster between Availability Zones after the cluster modification is complete.
        public let availabilityZoneRelocation: Bool?
        /// The unique identifier of the cluster to be modified. Example: examplecluster
        public let clusterIdentifier: String?
        /// The name of the cluster parameter group to apply to this cluster. This change is applied only after the cluster is rebooted. To reboot a cluster use RebootCluster.  Default: Uses existing setting. Constraints: The cluster parameter group must be in the same parameter group family that matches the cluster version.
        public let clusterParameterGroupName: String?
        /// A list of cluster security groups to be authorized on this cluster. This change is asynchronously applied as soon as possible. Security groups currently associated with the cluster, and not in the list of groups to apply, will be revoked from the cluster. Constraints:   Must be 1 to 255 alphanumeric characters or hyphens   First character must be a letter   Cannot end with a hyphen or contain two consecutive hyphens
        @OptionalCustomCoding<ArrayCoder<_ClusterSecurityGroupsEncoding, String>>
        public var clusterSecurityGroups: [String]?
        /// The new cluster type. When you submit your cluster resize request, your existing cluster goes into a read-only mode. After Amazon Redshift provisions a new cluster based on your resize requirements, there will be outage for a period while the old cluster is deleted and your connection is switched to the new cluster. You can use DescribeResize to track the progress of the resize request.  Valid Values:  multi-node | single-node
        public let clusterType: String?
        /// The new version number of the Amazon Redshift engine to upgrade to. For major version upgrades, if a non-default cluster parameter group is currently in use, a new cluster parameter group in the cluster parameter group family for the new version must be specified. The new cluster parameter group can be the default for that cluster parameter group family.
        /// For more information about parameters and parameter groups, go to
        /// Amazon Redshift Parameter Groups
        /// in the Amazon Redshift Cluster Management Guide. Example: 1.0
        public let clusterVersion: String?
        /// The Elastic IP (EIP) address for the cluster. Constraints: The cluster must be provisioned in EC2-VPC and publicly-accessible through an Internet gateway. For more information about provisioning clusters in EC2-VPC, go to Supported Platforms to Launch Your Cluster in the Amazon Redshift Cluster Management Guide.
        public let elasticIp: String?
        /// Indicates whether the cluster is encrypted. If the value is encrypted (true) and you provide a value for the KmsKeyId parameter, we encrypt the cluster with the provided KmsKeyId. If you don't provide a KmsKeyId, we encrypt with the default key.  If the value is not encrypted (false), then the cluster is decrypted.
        public let encrypted: Bool?
        /// An option that specifies whether to create the cluster with enhanced VPC routing enabled. To create a cluster that uses enhanced VPC routing, the cluster must be in a VPC. For more information, see Enhanced VPC Routing in the Amazon Redshift Cluster Management Guide. If this option is true, enhanced VPC routing is enabled.  Default: false
        public let enhancedVpcRouting: Bool?
        /// Specifies the name of the HSM client certificate the Amazon Redshift cluster uses to retrieve the data encryption keys stored in an HSM.
        public let hsmClientCertificateIdentifier: String?
        /// Specifies the name of the HSM configuration that contains the information the Amazon Redshift cluster can use to retrieve and store keys in an HSM.
        public let hsmConfigurationIdentifier: String?
        /// The IP address types that the cluster supports. Possible values are ipv4 and dualstack.
        public let ipAddressType: String?
        /// The Key Management Service (KMS) key ID of the encryption key that you want to use to encrypt data in the cluster.
        public let kmsKeyId: String?
        /// The name for the maintenance track that you want to assign for the cluster. This name change is asynchronous. The new track name stays in the PendingModifiedValues for the cluster until the next maintenance window. When the maintenance track changes, the cluster is switched to the latest cluster release available for the maintenance track. At this point, the maintenance track name is applied.
        public let maintenanceTrackName: String?
        /// If true, Amazon Redshift uses Secrets Manager to manage this cluster's admin credentials.  You can't use MasterUserPassword if ManageMasterPassword is true.  If ManageMasterPassword is false or not set, Amazon Redshift uses  MasterUserPassword for the admin user account's password.
        public let manageMasterPassword: Bool?
        /// The default for number of days that a newly created manual snapshot is retained. If the value is -1, the manual snapshot is retained indefinitely. This value doesn't retroactively change the retention periods of existing manual snapshots. The value must be either -1 or an integer between 1 and 3,653. The default value is -1.
        public let manualSnapshotRetentionPeriod: Int?
        /// The ID of the Key Management Service (KMS) key used to encrypt and store the cluster's admin credentials secret.  You can only use this parameter if ManageMasterPassword is true.
        public let masterPasswordSecretKmsKeyId: String?
        /// The new password for the cluster admin user. This change is asynchronously applied as soon as possible. Between the time of the request and the completion of the request, the MasterUserPassword element exists in the PendingModifiedValues element of the operation response.  You can't use MasterUserPassword if ManageMasterPassword is true.  Operations never return the password, so this operation provides a way to regain access to the admin user account for a cluster if the password is lost.  Default: Uses existing setting. Constraints:   Must be between 8 and 64 characters in length.   Must contain at least one uppercase letter.   Must contain at least one lowercase letter.   Must contain one number.   Can be any printable ASCII character (ASCII code 33-126) except ' (single quote), " (double quote), \, /, or @.
        public let masterUserPassword: String?
        /// If true and the cluster is currently only deployed in a single Availability Zone, the cluster will be modified to be deployed in two Availability Zones.
        public let multiAZ: Bool?
        /// The new identifier for the cluster. Constraints:   Must contain from 1 to 63 alphanumeric characters or hyphens.   Alphabetic characters must be lowercase.   First character must be a letter.   Cannot end with a hyphen or contain two consecutive hyphens.   Must be unique for all clusters within an Amazon Web Services account.   Example: examplecluster
        public let newClusterIdentifier: String?
        /// The new node type of the cluster. If you specify a new node type, you must also specify the number of nodes parameter.
        /// For more information about resizing clusters, go to
        /// Resizing Clusters in Amazon Redshift
        /// in the Amazon Redshift Cluster Management Guide. Valid Values:  dc2.large | dc2.8xlarge |  ra3.large |  ra3.xlplus |  ra3.4xlarge | ra3.16xlarge
        public let nodeType: String?
        /// The new number of nodes of the cluster. If you specify a new number of nodes, you must also specify the node type parameter.
        /// For more information about resizing clusters, go to
        /// Resizing Clusters in Amazon Redshift
        /// in the Amazon Redshift Cluster Management Guide. Valid Values: Integer greater than 0.
        public let numberOfNodes: Int?
        /// The option to change the port of an Amazon Redshift cluster. Valid Values:    For clusters with ra3 nodes - Select a port within the ranges 5431-5455 or 8191-8215. (If you have an existing cluster  with ra3 nodes, it isn't required that you change the port to these ranges.)   For clusters with dc2 nodes - Select a port within the range 1150-65535.
        public let port: Int?
        /// The weekly time range (in UTC) during which system maintenance can occur, if necessary. If system maintenance is necessary during the window, it may result in an outage. This maintenance window change is made immediately. If the new maintenance window indicates the current time, there must be at least 120 minutes between the current time and end of the window in order to ensure that pending changes are applied. Default: Uses existing setting. Format: ddd:hh24:mi-ddd:hh24:mi, for example wed:07:30-wed:08:00. Valid Days: Mon | Tue | Wed | Thu | Fri | Sat | Sun Constraints: Must be at least 30 minutes.
        public let preferredMaintenanceWindow: String?
        /// If true, the cluster can be accessed from a public network. Only clusters in VPCs can be set to be publicly available. Default: false
        public let publiclyAccessible: Bool?
        /// A list of virtual private cloud (VPC) security groups to be associated with the cluster. This change is asynchronously applied as soon as possible.
        @OptionalCustomCoding<ArrayCoder<_VpcSecurityGroupIdsEncoding, String>>
        public var vpcSecurityGroupIds: [String]?

        @inlinable
        public init(allowVersionUpgrade: Bool? = nil, automatedSnapshotRetentionPeriod: Int? = nil, availabilityZone: String? = nil, availabilityZoneRelocation: Bool? = nil, clusterIdentifier: String? = nil, clusterParameterGroupName: String? = nil, clusterSecurityGroups: [String]? = nil, clusterType: String? = nil, clusterVersion: String? = nil, elasticIp: String? = nil, encrypted: Bool? = nil, enhancedVpcRouting: Bool? = nil, hsmClientCertificateIdentifier: String? = nil, hsmConfigurationIdentifier: String? = nil, ipAddressType: String? = nil, kmsKeyId: String? = nil, maintenanceTrackName: String? = nil, manageMasterPassword: Bool? = nil, manualSnapshotRetentionPeriod: Int? = nil, masterPasswordSecretKmsKeyId: String? = nil, masterUserPassword: String? = nil, multiAZ: Bool? = nil, newClusterIdentifier: String? = nil, nodeType: String? = nil, numberOfNodes: Int? = nil, port: Int? = nil, preferredMaintenanceWindow: String? = nil, publiclyAccessible: Bool? = nil, vpcSecurityGroupIds: [String]? = nil) {
            self.allowVersionUpgrade = allowVersionUpgrade
            self.automatedSnapshotRetentionPeriod = automatedSnapshotRetentionPeriod
            self.availabilityZone = availabilityZone
            self.availabilityZoneRelocation = availabilityZoneRelocation
            self.clusterIdentifier = clusterIdentifier
            self.clusterParameterGroupName = clusterParameterGroupName
            self.clusterSecurityGroups = clusterSecurityGroups
            self.clusterType = clusterType
            self.clusterVersion = clusterVersion
            self.elasticIp = elasticIp
            self.encrypted = encrypted
            self.enhancedVpcRouting = enhancedVpcRouting
            self.hsmClientCertificateIdentifier = hsmClientCertificateIdentifier
            self.hsmConfigurationIdentifier = hsmConfigurationIdentifier
            self.ipAddressType = ipAddressType
            self.kmsKeyId = kmsKeyId
            self.maintenanceTrackName = maintenanceTrackName
            self.manageMasterPassword = manageMasterPassword
            self.manualSnapshotRetentionPeriod = manualSnapshotRetentionPeriod
            self.masterPasswordSecretKmsKeyId = masterPasswordSecretKmsKeyId
            self.masterUserPassword = masterUserPassword
            self.multiAZ = multiAZ
            self.newClusterIdentifier = newClusterIdentifier
            self.nodeType = nodeType
            self.numberOfNodes = numberOfNodes
            self.port = port
            self.preferredMaintenanceWindow = preferredMaintenanceWindow
            self.publiclyAccessible = publiclyAccessible
            self.vpcSecurityGroupIds = vpcSecurityGroupIds
        }

        public func validate(name: String) throws {
            try self.validate(self.availabilityZone, name: "availabilityZone", parent: name, max: 2147483647)
            try self.validate(self.clusterIdentifier, name: "clusterIdentifier", parent: name, max: 2147483647)
            try self.validate(self.clusterParameterGroupName, name: "clusterParameterGroupName", parent: name, max: 2147483647)
            try self.clusterSecurityGroups?.forEach {
                try validate($0, name: "clusterSecurityGroups[]", parent: name, max: 2147483647)
            }
            try self.validate(self.clusterType, name: "clusterType", parent: name, max: 2147483647)
            try self.validate(self.clusterVersion, name: "clusterVersion", parent: name, max: 2147483647)
            try self.validate(self.elasticIp, name: "elasticIp", parent: name, max: 2147483647)
            try self.validate(self.hsmClientCertificateIdentifier, name: "hsmClientCertificateIdentifier", parent: name, max: 2147483647)
            try self.validate(self.hsmConfigurationIdentifier, name: "hsmConfigurationIdentifier", parent: name, max: 2147483647)
            try self.validate(self.ipAddressType, name: "ipAddressType", parent: name, max: 2147483647)
            try self.validate(self.kmsKeyId, name: "kmsKeyId", parent: name, max: 2147483647)
            try self.validate(self.maintenanceTrackName, name: "maintenanceTrackName", parent: name, max: 2147483647)
            try self.validate(self.masterPasswordSecretKmsKeyId, name: "masterPasswordSecretKmsKeyId", parent: name, max: 2147483647)
            try self.validate(self.newClusterIdentifier, name: "newClusterIdentifier", parent: name, max: 2147483647)
            try self.validate(self.nodeType, name: "nodeType", parent: name, max: 2147483647)
            try self.validate(self.preferredMaintenanceWindow, name: "preferredMaintenanceWindow", parent: name, max: 2147483647)
            try self.vpcSecurityGroupIds?.forEach {
                try validate($0, name: "vpcSecurityGroupIds[]", parent: name, max: 2147483647)
            }
        }

        private enum CodingKeys: String, CodingKey {
            case allowVersionUpgrade = "AllowVersionUpgrade"
            case automatedSnapshotRetentionPeriod = "AutomatedSnapshotRetentionPeriod"
            case availabilityZone = "AvailabilityZone"
            case availabilityZoneRelocation = "AvailabilityZoneRelocation"
            case clusterIdentifier = "ClusterIdentifier"
            case clusterParameterGroupName = "ClusterParameterGroupName"
            case clusterSecurityGroups = "ClusterSecurityGroups"
            case clusterType = "ClusterType"
            case clusterVersion = "ClusterVersion"
            case elasticIp = "ElasticIp"
            case encrypted = "Encrypted"
            case enhancedVpcRouting = "EnhancedVpcRouting"
            case hsmClientCertificateIdentifier = "HsmClientCertificateIdentifier"
            case hsmConfigurationIdentifier = "HsmConfigurationIdentifier"
            case ipAddressType = "IpAddressType"
            case kmsKeyId = "KmsKeyId"
            case maintenanceTrackName = "MaintenanceTrackName"
            case manageMasterPassword = "ManageMasterPassword"
            case manualSnapshotRetentionPeriod = "ManualSnapshotRetentionPeriod"
            case masterPasswordSecretKmsKeyId = "MasterPasswordSecretKmsKeyId"
            case masterUserPassword = "MasterUserPassword"
            case multiAZ = "MultiAZ"
            case newClusterIdentifier = "NewClusterIdentifier"
            case nodeType = "NodeType"
            case numberOfNodes = "NumberOfNodes"
            case port = "Port"
            case preferredMaintenanceWindow = "PreferredMaintenanceWindow"
            case publiclyAccessible = "PubliclyAccessible"
            case vpcSecurityGroupIds = "VpcSecurityGroupIds"
        }
    }

    public struct ModifyClusterParameterGroupMessage: AWSEncodableShape {
        public struct _ParametersEncoding: ArrayCoderProperties { public static let member = "Parameter" }

        /// The name of the parameter group to be modified.
        public let parameterGroupName: String?
        /// An array of parameters to be modified. A maximum of 20 parameters can be modified in a single request. For each parameter to be modified, you must supply at least the parameter name and parameter value; other name-value pairs of the parameter are optional. For the workload management (WLM) configuration, you must supply all the name-value pairs in the wlm_json_configuration parameter.
        @OptionalCustomCoding<ArrayCoder<_ParametersEncoding, Parameter>>
        public var parameters: [Parameter]?

        @inlinable
        public init(parameterGroupName: String? = nil, parameters: [Parameter]? = nil) {
            self.parameterGroupName = parameterGroupName
            self.parameters = parameters
        }

        public func validate(name: String) throws {
            try self.validate(self.parameterGroupName, name: "parameterGroupName", parent: name, max: 2147483647)
            try self.parameters?.forEach {
                try $0.validate(name: "\(name).parameters[]")
            }
        }

        private enum CodingKeys: String, CodingKey {
            case parameterGroupName = "ParameterGroupName"
            case parameters = "Parameters"
        }
    }

    public struct ModifyClusterResult: AWSDecodableShape {
        public let cluster: Cluster?

        @inlinable
        public init(cluster: Cluster? = nil) {
            self.cluster = cluster
        }

        private enum CodingKeys: String, CodingKey {
            case cluster = "Cluster"
        }
    }

    public struct ModifyClusterSnapshotMessage: AWSEncodableShape {
        /// A Boolean option to override an exception if the retention period has already passed.
        public let force: Bool?
        /// The number of days that a manual snapshot is retained. If the value is -1, the manual snapshot is retained indefinitely. If the manual snapshot falls outside of the new retention period, you can specify the force option to immediately delete the snapshot. The value must be either -1 or an integer between 1 and 3,653.
        public let manualSnapshotRetentionPeriod: Int?
        /// The identifier of the snapshot whose setting you want to modify.
        public let snapshotIdentifier: String?

        @inlinable
        public init(force: Bool? = nil, manualSnapshotRetentionPeriod: Int? = nil, snapshotIdentifier: String? = nil) {
            self.force = force
            self.manualSnapshotRetentionPeriod = manualSnapshotRetentionPeriod
            self.snapshotIdentifier = snapshotIdentifier
        }

        public func validate(name: String) throws {
            try self.validate(self.snapshotIdentifier, name: "snapshotIdentifier", parent: name, max: 2147483647)
        }

        private enum CodingKeys: String, CodingKey {
            case force = "Force"
            case manualSnapshotRetentionPeriod = "ManualSnapshotRetentionPeriod"
            case snapshotIdentifier = "SnapshotIdentifier"
        }
    }

    public struct ModifyClusterSnapshotResult: AWSDecodableShape {
        public let snapshot: Snapshot?

        @inlinable
        public init(snapshot: Snapshot? = nil) {
            self.snapshot = snapshot
        }

        private enum CodingKeys: String, CodingKey {
            case snapshot = "Snapshot"
        }
    }

    public struct ModifyClusterSnapshotScheduleMessage: AWSEncodableShape {
        /// A unique identifier for the cluster whose snapshot schedule you want to modify.
        public let clusterIdentifier: String?
        /// A boolean to indicate whether to remove the assoiciation between the cluster and the schedule.
        public let disassociateSchedule: Bool?
        /// A unique alphanumeric identifier for the schedule that you want to associate with the cluster.
        public let scheduleIdentifier: String?

        @inlinable
        public init(clusterIdentifier: String? = nil, disassociateSchedule: Bool? = nil, scheduleIdentifier: String? = nil) {
            self.clusterIdentifier = clusterIdentifier
            self.disassociateSchedule = disassociateSchedule
            self.scheduleIdentifier = scheduleIdentifier
        }

        public func validate(name: String) throws {
            try self.validate(self.clusterIdentifier, name: "clusterIdentifier", parent: name, max: 2147483647)
            try self.validate(self.scheduleIdentifier, name: "scheduleIdentifier", parent: name, max: 2147483647)
        }

        private enum CodingKeys: String, CodingKey {
            case clusterIdentifier = "ClusterIdentifier"
            case disassociateSchedule = "DisassociateSchedule"
            case scheduleIdentifier = "ScheduleIdentifier"
        }
    }

    public struct ModifyClusterSubnetGroupMessage: AWSEncodableShape {
        public struct _SubnetIdsEncoding: ArrayCoderProperties { public static let member = "SubnetIdentifier" }

        /// The name of the subnet group to be modified.
        public let clusterSubnetGroupName: String?
        /// A text description of the subnet group to be modified.
        public let description: String?
        /// An array of VPC subnet IDs. A maximum of 20 subnets can be modified in a single request.
        @OptionalCustomCoding<ArrayCoder<_SubnetIdsEncoding, String>>
        public var subnetIds: [String]?

        @inlinable
        public init(clusterSubnetGroupName: String? = nil, description: String? = nil, subnetIds: [String]? = nil) {
            self.clusterSubnetGroupName = clusterSubnetGroupName
            self.description = description
            self.subnetIds = subnetIds
        }

        public func validate(name: String) throws {
            try self.validate(self.clusterSubnetGroupName, name: "clusterSubnetGroupName", parent: name, max: 2147483647)
            try self.validate(self.description, name: "description", parent: name, max: 2147483647)
            try self.subnetIds?.forEach {
                try validate($0, name: "subnetIds[]", parent: name, max: 2147483647)
            }
        }

        private enum CodingKeys: String, CodingKey {
            case clusterSubnetGroupName = "ClusterSubnetGroupName"
            case description = "Description"
            case subnetIds = "SubnetIds"
        }
    }

    public struct ModifyClusterSubnetGroupResult: AWSDecodableShape {
        public let clusterSubnetGroup: ClusterSubnetGroup?

        @inlinable
        public init(clusterSubnetGroup: ClusterSubnetGroup? = nil) {
            self.clusterSubnetGroup = clusterSubnetGroup
        }

        private enum CodingKeys: String, CodingKey {
            case clusterSubnetGroup = "ClusterSubnetGroup"
        }
    }

    public struct ModifyCustomDomainAssociationMessage: AWSEncodableShape {
        /// The identifier of the cluster to change a custom domain association for.
        public let clusterIdentifier: String?
        /// The certificate Amazon Resource Name (ARN) for the changed custom domain association.
        public let customDomainCertificateArn: String?
        /// The custom domain name for a changed custom domain association.
        public let customDomainName: String?

        @inlinable
        public init(clusterIdentifier: String? = nil, customDomainCertificateArn: String? = nil, customDomainName: String? = nil) {
            self.clusterIdentifier = clusterIdentifier
            self.customDomainCertificateArn = customDomainCertificateArn
            self.customDomainName = customDomainName
        }

        public func validate(name: String) throws {
            try self.validate(self.clusterIdentifier, name: "clusterIdentifier", parent: name, max: 2147483647)
            try self.validate(self.customDomainCertificateArn, name: "customDomainCertificateArn", parent: name, max: 2048)
            try self.validate(self.customDomainCertificateArn, name: "customDomainCertificateArn", parent: name, min: 20)
            try self.validate(self.customDomainCertificateArn, name: "customDomainCertificateArn", parent: name, pattern: "^arn:[\\w+=/,.@-]+:acm:[\\w+=/,.@-]*:[0-9]+:[\\w+=,.@-]+(/[\\w+=,.@-]+)*$")
            try self.validate(self.customDomainName, name: "customDomainName", parent: name, max: 253)
            try self.validate(self.customDomainName, name: "customDomainName", parent: name, min: 1)
            try self.validate(self.customDomainName, name: "customDomainName", parent: name, pattern: "^(((?!-)[A-Za-z0-9-]{0,62}[A-Za-z0-9])\\.)+((?!-)[A-Za-z0-9-]{1,62}[A-Za-z0-9])$")
        }

        private enum CodingKeys: String, CodingKey {
            case clusterIdentifier = "ClusterIdentifier"
            case customDomainCertificateArn = "CustomDomainCertificateArn"
            case customDomainName = "CustomDomainName"
        }
    }

    public struct ModifyCustomDomainAssociationResult: AWSDecodableShape {
        /// The identifier of the cluster associated with the result for the changed custom domain association.
        public let clusterIdentifier: String?
        /// The certificate expiration time associated with the result for the changed custom domain association.
        public let customDomainCertExpiryTime: String?
        /// The certificate Amazon Resource Name (ARN) associated with the result for the changed custom domain association.
        public let customDomainCertificateArn: String?
        /// The custom domain name associated with the result for the changed custom domain association.
        public let customDomainName: String?

        @inlinable
        public init(clusterIdentifier: String? = nil, customDomainCertExpiryTime: String? = nil, customDomainCertificateArn: String? = nil, customDomainName: String? = nil) {
            self.clusterIdentifier = clusterIdentifier
            self.customDomainCertExpiryTime = customDomainCertExpiryTime
            self.customDomainCertificateArn = customDomainCertificateArn
            self.customDomainName = customDomainName
        }

        private enum CodingKeys: String, CodingKey {
            case clusterIdentifier = "ClusterIdentifier"
            case customDomainCertExpiryTime = "CustomDomainCertExpiryTime"
            case customDomainCertificateArn = "CustomDomainCertificateArn"
            case customDomainName = "CustomDomainName"
        }
    }

    public struct ModifyEndpointAccessMessage: AWSEncodableShape {
        public struct _VpcSecurityGroupIdsEncoding: ArrayCoderProperties { public static let member = "VpcSecurityGroupId" }

        /// The endpoint to be modified.
        public let endpointName: String?
        /// The complete list of VPC security groups associated with the endpoint after the endpoint is modified.
        @OptionalCustomCoding<ArrayCoder<_VpcSecurityGroupIdsEncoding, String>>
        public var vpcSecurityGroupIds: [String]?

        @inlinable
        public init(endpointName: String? = nil, vpcSecurityGroupIds: [String]? = nil) {
            self.endpointName = endpointName
            self.vpcSecurityGroupIds = vpcSecurityGroupIds
        }

        public func validate(name: String) throws {
            try self.validate(self.endpointName, name: "endpointName", parent: name, max: 2147483647)
            try self.vpcSecurityGroupIds?.forEach {
                try validate($0, name: "vpcSecurityGroupIds[]", parent: name, max: 2147483647)
            }
        }

        private enum CodingKeys: String, CodingKey {
            case endpointName = "EndpointName"
            case vpcSecurityGroupIds = "VpcSecurityGroupIds"
        }
    }

    public struct ModifyEventSubscriptionMessage: AWSEncodableShape {
        public struct _EventCategoriesEncoding: ArrayCoderProperties { public static let member = "EventCategory" }
        public struct _SourceIdsEncoding: ArrayCoderProperties { public static let member = "SourceId" }

        /// A Boolean value indicating if the subscription is enabled. true indicates the subscription is enabled
        public let enabled: Bool?
        /// Specifies the Amazon Redshift event categories to be published by the event notification subscription. Values: configuration, management, monitoring, security, pending
        @OptionalCustomCoding<ArrayCoder<_EventCategoriesEncoding, String>>
        public var eventCategories: [String]?
        /// Specifies the Amazon Redshift event severity to be published by the event notification subscription. Values: ERROR, INFO
        public let severity: String?
        /// The Amazon Resource Name (ARN) of the SNS topic to be used by the event notification subscription.
        public let snsTopicArn: String?
        /// A list of one or more identifiers of Amazon Redshift source objects. All of the objects must be of the same type as was specified in the source type parameter. The event subscription will return only events generated by the specified objects. If not specified, then events are returned for all objects within the source type specified. Example: my-cluster-1, my-cluster-2 Example: my-snapshot-20131010
        @OptionalCustomCoding<ArrayCoder<_SourceIdsEncoding, String>>
        public var sourceIds: [String]?
        /// The type of source that will be generating the events. For example, if you want to be notified of events generated by a cluster, you would set this parameter to cluster. If this value is not specified, events are returned for all Amazon Redshift objects in your Amazon Web Services account. You must specify a source type in order to specify source IDs. Valid values: cluster, cluster-parameter-group, cluster-security-group, cluster-snapshot, and scheduled-action.
        public let sourceType: String?
        /// The name of the modified Amazon Redshift event notification subscription.
        public let subscriptionName: String?

        @inlinable
        public init(enabled: Bool? = nil, eventCategories: [String]? = nil, severity: String? = nil, snsTopicArn: String? = nil, sourceIds: [String]? = nil, sourceType: String? = nil, subscriptionName: String? = nil) {
            self.enabled = enabled
            self.eventCategories = eventCategories
            self.severity = severity
            self.snsTopicArn = snsTopicArn
            self.sourceIds = sourceIds
            self.sourceType = sourceType
            self.subscriptionName = subscriptionName
        }

        public func validate(name: String) throws {
            try self.eventCategories?.forEach {
                try validate($0, name: "eventCategories[]", parent: name, max: 2147483647)
            }
            try self.validate(self.severity, name: "severity", parent: name, max: 2147483647)
            try self.validate(self.snsTopicArn, name: "snsTopicArn", parent: name, max: 2147483647)
            try self.sourceIds?.forEach {
                try validate($0, name: "sourceIds[]", parent: name, max: 2147483647)
            }
            try self.validate(self.sourceType, name: "sourceType", parent: name, max: 2147483647)
            try self.validate(self.subscriptionName, name: "subscriptionName", parent: name, max: 2147483647)
        }

        private enum CodingKeys: String, CodingKey {
            case enabled = "Enabled"
            case eventCategories = "EventCategories"
            case severity = "Severity"
            case snsTopicArn = "SnsTopicArn"
            case sourceIds = "SourceIds"
            case sourceType = "SourceType"
            case subscriptionName = "SubscriptionName"
        }
    }

    public struct ModifyEventSubscriptionResult: AWSDecodableShape {
        public let eventSubscription: EventSubscription?

        @inlinable
        public init(eventSubscription: EventSubscription? = nil) {
            self.eventSubscription = eventSubscription
        }

        private enum CodingKeys: String, CodingKey {
            case eventSubscription = "EventSubscription"
        }
    }

    public struct ModifyIntegrationMessage: AWSEncodableShape {
        /// A new description for the integration.
        public let description: String?
        /// The unique identifier of the integration to modify.
        public let integrationArn: String?
        /// A new name for the integration.
        public let integrationName: String?

        @inlinable
        public init(description: String? = nil, integrationArn: String? = nil, integrationName: String? = nil) {
            self.description = description
            self.integrationArn = integrationArn
            self.integrationName = integrationName
        }

        public func validate(name: String) throws {
            try self.validate(self.description, name: "description", parent: name, max: 1000)
            try self.validate(self.description, name: "description", parent: name, pattern: "^.*$")
            try self.validate(self.integrationArn, name: "integrationArn", parent: name, max: 255)
            try self.validate(self.integrationArn, name: "integrationArn", parent: name, min: 1)
            try self.validate(self.integrationArn, name: "integrationArn", parent: name, pattern: "^arn:aws[a-z\\-]*:redshift:[a-z0-9\\-]*:[0-9]*:integration:[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$")
            try self.validate(self.integrationName, name: "integrationName", parent: name, max: 63)
            try self.validate(self.integrationName, name: "integrationName", parent: name, min: 1)
            try self.validate(self.integrationName, name: "integrationName", parent: name, pattern: "^[a-zA-Z][a-zA-Z0-9]*(-[a-zA-Z0-9]+)*$")
        }

        private enum CodingKeys: String, CodingKey {
            case description = "Description"
            case integrationArn = "IntegrationArn"
            case integrationName = "IntegrationName"
        }
    }

    public struct ModifyRedshiftIdcApplicationMessage: AWSEncodableShape {
        /// The authorized token issuer list for the Amazon Redshift IAM Identity Center application to change.
        @OptionalCustomCoding<StandardArrayCoder<AuthorizedTokenIssuer>>
        public var authorizedTokenIssuerList: [AuthorizedTokenIssuer]?
        /// The IAM role ARN associated with the Amazon Redshift IAM Identity Center application to change. It has the required permissions  to be assumed and invoke the IDC Identity Center API.
        public let iamRoleArn: String?
        /// The display name for the Amazon Redshift IAM Identity Center application to change. It appears on the console.
        public let idcDisplayName: String?
        /// The namespace for the Amazon Redshift IAM Identity Center application to change. It determines which managed application  verifies the connection token.
        public let identityNamespace: String?
        /// The ARN for the Redshift application that integrates with IAM Identity Center.
        public let redshiftIdcApplicationArn: String?
        /// A collection of service integrations associated with the application.
        @OptionalCustomCoding<StandardArrayCoder<ServiceIntegrationsUnion>>
        public var serviceIntegrations: [ServiceIntegrationsUnion]?

        @inlinable
        public init(authorizedTokenIssuerList: [AuthorizedTokenIssuer]? = nil, iamRoleArn: String? = nil, idcDisplayName: String? = nil, identityNamespace: String? = nil, redshiftIdcApplicationArn: String? = nil, serviceIntegrations: [ServiceIntegrationsUnion]? = nil) {
            self.authorizedTokenIssuerList = authorizedTokenIssuerList
            self.iamRoleArn = iamRoleArn
            self.idcDisplayName = idcDisplayName
            self.identityNamespace = identityNamespace
            self.redshiftIdcApplicationArn = redshiftIdcApplicationArn
            self.serviceIntegrations = serviceIntegrations
        }

        public func validate(name: String) throws {
            try self.authorizedTokenIssuerList?.forEach {
                try $0.validate(name: "\(name).authorizedTokenIssuerList[]")
            }
            try self.validate(self.iamRoleArn, name: "iamRoleArn", parent: name, max: 2147483647)
            try self.validate(self.idcDisplayName, name: "idcDisplayName", parent: name, max: 127)
            try self.validate(self.idcDisplayName, name: "idcDisplayName", parent: name, min: 1)
            try self.validate(self.idcDisplayName, name: "idcDisplayName", parent: name, pattern: "^[\\w+=,.@-]+$")
            try self.validate(self.identityNamespace, name: "identityNamespace", parent: name, max: 127)
            try self.validate(self.identityNamespace, name: "identityNamespace", parent: name, min: 1)
            try self.validate(self.identityNamespace, name: "identityNamespace", parent: name, pattern: "^[a-zA-Z0-9_+.#@$-]+$")
            try self.validate(self.redshiftIdcApplicationArn, name: "redshiftIdcApplicationArn", parent: name, max: 2147483647)
        }

        private enum CodingKeys: String, CodingKey {
            case authorizedTokenIssuerList = "AuthorizedTokenIssuerList"
            case iamRoleArn = "IamRoleArn"
            case idcDisplayName = "IdcDisplayName"
            case identityNamespace = "IdentityNamespace"
            case redshiftIdcApplicationArn = "RedshiftIdcApplicationArn"
            case serviceIntegrations = "ServiceIntegrations"
        }
    }

    public struct ModifyRedshiftIdcApplicationResult: AWSDecodableShape {
        public let redshiftIdcApplication: RedshiftIdcApplication?

        @inlinable
        public init(redshiftIdcApplication: RedshiftIdcApplication? = nil) {
            self.redshiftIdcApplication = redshiftIdcApplication
        }

        private enum CodingKeys: String, CodingKey {
            case redshiftIdcApplication = "RedshiftIdcApplication"
        }
    }

    public struct ModifyScheduledActionMessage: AWSEncodableShape {
        /// A modified enable flag of the scheduled action. If true, the scheduled action is active. If false, the scheduled action is disabled.
        public let enable: Bool?
        /// A modified end time of the scheduled action.  For more information about this parameter, see ScheduledAction.
        public let endTime: Date?
        /// A different IAM role to assume to run the target action.  For more information about this parameter, see ScheduledAction.
        public let iamRole: String?
        /// A modified schedule in either at( ) or cron( ) format.  For more information about this parameter, see ScheduledAction.
        public let schedule: String?
        /// A modified description of the scheduled action.
        public let scheduledActionDescription: String?
        /// The name of the scheduled action to modify.
        public let scheduledActionName: String?
        /// A modified start time of the scheduled action.  For more information about this parameter, see ScheduledAction.
        public let startTime: Date?
        /// A modified JSON format of the scheduled action.  For more information about this parameter, see ScheduledAction.
        public let targetAction: ScheduledActionType?

        @inlinable
        public init(enable: Bool? = nil, endTime: Date? = nil, iamRole: String? = nil, schedule: String? = nil, scheduledActionDescription: String? = nil, scheduledActionName: String? = nil, startTime: Date? = nil, targetAction: ScheduledActionType? = nil) {
            self.enable = enable
            self.endTime = endTime
            self.iamRole = iamRole
            self.schedule = schedule
            self.scheduledActionDescription = scheduledActionDescription
            self.scheduledActionName = scheduledActionName
            self.startTime = startTime
            self.targetAction = targetAction
        }

        public func validate(name: String) throws {
            try self.validate(self.iamRole, name: "iamRole", parent: name, max: 2147483647)
            try self.validate(self.schedule, name: "schedule", parent: name, max: 2147483647)
            try self.validate(self.scheduledActionDescription, name: "scheduledActionDescription", parent: name, max: 2147483647)
            try self.validate(self.scheduledActionName, name: "scheduledActionName", parent: name, max: 2147483647)
            try self.targetAction?.validate(name: "\(name).targetAction")
        }

        private enum CodingKeys: String, CodingKey {
            case enable = "Enable"
            case endTime = "EndTime"
            case iamRole = "IamRole"
            case schedule = "Schedule"
            case scheduledActionDescription = "ScheduledActionDescription"
            case scheduledActionName = "ScheduledActionName"
            case startTime = "StartTime"
            case targetAction = "TargetAction"
        }
    }

    public struct ModifySnapshotCopyRetentionPeriodMessage: AWSEncodableShape {
        /// The unique identifier of the cluster for which you want to change the retention period for either automated or manual snapshots that are copied to a destination Amazon Web Services Region. Constraints: Must be the valid name of an existing cluster that has cross-region snapshot copy enabled.
        public let clusterIdentifier: String?
        /// Indicates whether to apply the snapshot retention period to newly copied manual snapshots instead of automated snapshots.
        public let manual: Bool?
        /// The number of days to retain automated snapshots in the destination Amazon Web Services Region after they are copied from the source Amazon Web Services Region. By default, this only changes the retention period of copied automated snapshots.  If you decrease the retention period for automated snapshots that are copied to a destination Amazon Web Services Region, Amazon Redshift deletes any existing automated snapshots that were copied to the destination Amazon Web Services Region and that fall outside of the new retention period. Constraints: Must be at least 1 and no more than 35 for automated snapshots.  If you specify the manual option, only newly copied manual snapshots will have the new retention period.  If you specify the value of -1 newly copied manual snapshots are retained indefinitely. Constraints: The number of days must be either -1 or an integer between 1 and 3,653 for manual snapshots.
        public let retentionPeriod: Int?

        @inlinable
        public init(clusterIdentifier: String? = nil, manual: Bool? = nil, retentionPeriod: Int? = nil) {
            self.clusterIdentifier = clusterIdentifier
            self.manual = manual
            self.retentionPeriod = retentionPeriod
        }

        public func validate(name: String) throws {
            try self.validate(self.clusterIdentifier, name: "clusterIdentifier", parent: name, max: 2147483647)
        }

        private enum CodingKeys: String, CodingKey {
            case clusterIdentifier = "ClusterIdentifier"
            case manual = "Manual"
            case retentionPeriod = "RetentionPeriod"
        }
    }

    public struct ModifySnapshotCopyRetentionPeriodResult: AWSDecodableShape {
        public let cluster: Cluster?

        @inlinable
        public init(cluster: Cluster? = nil) {
            self.cluster = cluster
        }

        private enum CodingKeys: String, CodingKey {
            case cluster = "Cluster"
        }
    }

    public struct ModifySnapshotScheduleMessage: AWSEncodableShape {
        public struct _ScheduleDefinitionsEncoding: ArrayCoderProperties { public static let member = "ScheduleDefinition" }

        /// An updated list of schedule definitions. A schedule definition is made up of schedule expressions, for example, "cron(30 12 *)" or "rate(12 hours)".
        @OptionalCustomCoding<ArrayCoder<_ScheduleDefinitionsEncoding, String>>
        public var scheduleDefinitions: [String]?
        /// A unique alphanumeric identifier of the schedule to modify.
        public let scheduleIdentifier: String?

        @inlinable
        public init(scheduleDefinitions: [String]? = nil, scheduleIdentifier: String? = nil) {
            self.scheduleDefinitions = scheduleDefinitions
            self.scheduleIdentifier = scheduleIdentifier
        }

        public func validate(name: String) throws {
            try self.scheduleDefinitions?.forEach {
                try validate($0, name: "scheduleDefinitions[]", parent: name, max: 2147483647)
            }
            try self.validate(self.scheduleIdentifier, name: "scheduleIdentifier", parent: name, max: 2147483647)
        }

        private enum CodingKeys: String, CodingKey {
            case scheduleDefinitions = "ScheduleDefinitions"
            case scheduleIdentifier = "ScheduleIdentifier"
        }
    }

    public struct ModifyUsageLimitMessage: AWSEncodableShape {
        /// The new limit amount.  For more information about this parameter, see UsageLimit.
        public let amount: Int64?
        /// The new action that Amazon Redshift takes when the limit is reached.  For more information about this parameter, see UsageLimit.
        public let breachAction: UsageLimitBreachAction?
        /// The identifier of the usage limit to modify.
        public let usageLimitId: String?

        @inlinable
        public init(amount: Int64? = nil, breachAction: UsageLimitBreachAction? = nil, usageLimitId: String? = nil) {
            self.amount = amount
            self.breachAction = breachAction
            self.usageLimitId = usageLimitId
        }

        public func validate(name: String) throws {
            try self.validate(self.usageLimitId, name: "usageLimitId", parent: name, max: 2147483647)
        }

        private enum CodingKeys: String, CodingKey {
            case amount = "Amount"
            case breachAction = "BreachAction"
            case usageLimitId = "UsageLimitId"
        }
    }

    public struct NetworkInterface: AWSDecodableShape {
        /// The Availability Zone.
        public let availabilityZone: String?
        /// The IPv6 address of the network interface within the subnet.
        public let ipv6Address: String?
        /// The network interface identifier.
        public let networkInterfaceId: String?
        /// The IPv4 address of the network interface within the subnet.
        public let privateIpAddress: String?
        /// The subnet identifier.
        public let subnetId: String?

        @inlinable
        public init(availabilityZone: String? = nil, ipv6Address: String? = nil, networkInterfaceId: String? = nil, privateIpAddress: String? = nil, subnetId: String? = nil) {
            self.availabilityZone = availabilityZone
            self.ipv6Address = ipv6Address
            self.networkInterfaceId = networkInterfaceId
            self.privateIpAddress = privateIpAddress
            self.subnetId = subnetId
        }

        private enum CodingKeys: String, CodingKey {
            case availabilityZone = "AvailabilityZone"
            case ipv6Address = "Ipv6Address"
            case networkInterfaceId = "NetworkInterfaceId"
            case privateIpAddress = "PrivateIpAddress"
            case subnetId = "SubnetId"
        }
    }

    public struct NodeConfigurationOption: AWSDecodableShape {
        /// The estimated disk utilizaton percentage.
        public let estimatedDiskUtilizationPercent: Double?
        /// The category of the node configuration recommendation.
        public let mode: Mode?
        /// The node type, such as, "ra3.4xlarge".
        public let nodeType: String?
        /// The number of nodes.
        public let numberOfNodes: Int?

        @inlinable
        public init(estimatedDiskUtilizationPercent: Double? = nil, mode: Mode? = nil, nodeType: String? = nil, numberOfNodes: Int? = nil) {
            self.estimatedDiskUtilizationPercent = estimatedDiskUtilizationPercent
            self.mode = mode
            self.nodeType = nodeType
            self.numberOfNodes = numberOfNodes
        }

        private enum CodingKeys: String, CodingKey {
            case estimatedDiskUtilizationPercent = "EstimatedDiskUtilizationPercent"
            case mode = "Mode"
            case nodeType = "NodeType"
            case numberOfNodes = "NumberOfNodes"
        }
    }

    public struct NodeConfigurationOptionsFilter: AWSEncodableShape {
        public struct _ValuesEncoding: ArrayCoderProperties { public static let member = "item" }

        /// The name of the element to filter.
        public let name: NodeConfigurationOptionsFilterName?
        /// The filter operator. If filter Name is NodeType only the 'in' operator is supported. Provide one value to evaluate for 'eq', 'lt', 'le', 'gt', and 'ge'.  Provide two values to evaluate for 'between'. Provide a list of values for 'in'.
        public let `operator`: OperatorType?
        /// List of values. Compare Name using Operator to Values. If filter Name is NumberOfNodes, then values can range from 0 to 200. If filter Name is EstimatedDiskUtilizationPercent, then values can range from 0 to 100.  For example, filter NumberOfNodes (name) GT (operator) 3 (values).
        @OptionalCustomCoding<ArrayCoder<_ValuesEncoding, String>>
        public var values: [String]?

        @inlinable
        public init(name: NodeConfigurationOptionsFilterName? = nil, operator: OperatorType? = nil, values: [String]? = nil) {
            self.name = name
            self.`operator` = `operator`
            self.values = values
        }

        public func validate(name: String) throws {
            try self.values?.forEach {
                try validate($0, name: "values[]", parent: name, max: 2147483647)
            }
        }

        private enum CodingKeys: String, CodingKey {
            case name = "Name"
            case `operator` = "Operator"
            case values = "Value"
        }
    }

    public struct NodeConfigurationOptionsMessage: AWSDecodableShape {
        public struct _NodeConfigurationOptionListEncoding: ArrayCoderProperties { public static let member = "NodeConfigurationOption" }

        /// A value that indicates the starting point for the next set of response records in a subsequent request. If a value is returned in a response, you can retrieve the next set of records by providing this returned marker value in the Marker parameter and retrying the command. If the Marker field is empty, all response records have been retrieved for the request.
        public let marker: String?
        /// A list of valid node configurations.
        @OptionalCustomCoding<ArrayCoder<_NodeConfigurationOptionListEncoding, NodeConfigurationOption>>
        public var nodeConfigurationOptionList: [NodeConfigurationOption]?

        @inlinable
        public init(marker: String? = nil, nodeConfigurationOptionList: [NodeConfigurationOption]? = nil) {
            self.marker = marker
            self.nodeConfigurationOptionList = nodeConfigurationOptionList
        }

        private enum CodingKeys: String, CodingKey {
            case marker = "Marker"
            case nodeConfigurationOptionList = "NodeConfigurationOptionList"
        }
    }

    public struct OrderableClusterOption: AWSDecodableShape {
        public struct _AvailabilityZonesEncoding: ArrayCoderProperties { public static let member = "AvailabilityZone" }

        /// A list of availability zones for the orderable cluster.
        @OptionalCustomCoding<ArrayCoder<_AvailabilityZonesEncoding, AvailabilityZone>>
        public var availabilityZones: [AvailabilityZone]?
        /// The cluster type, for example multi-node.
        public let clusterType: String?
        /// The version of the orderable cluster.
        public let clusterVersion: String?
        /// The node type for the orderable cluster.
        public let nodeType: String?

        @inlinable
        public init(availabilityZones: [AvailabilityZone]? = nil, clusterType: String? = nil, clusterVersion: String? = nil, nodeType: String? = nil) {
            self.availabilityZones = availabilityZones
            self.clusterType = clusterType
            self.clusterVersion = clusterVersion
            self.nodeType = nodeType
        }

        private enum CodingKeys: String, CodingKey {
            case availabilityZones = "AvailabilityZones"
            case clusterType = "ClusterType"
            case clusterVersion = "ClusterVersion"
            case nodeType = "NodeType"
        }
    }

    public struct OrderableClusterOptionsMessage: AWSDecodableShape {
        public struct _OrderableClusterOptionsEncoding: ArrayCoderProperties { public static let member = "OrderableClusterOption" }

        /// A value that indicates the starting point for the next set of response records in a subsequent request. If a value is returned in a response, you can retrieve the next set of records by providing this returned marker value in the Marker parameter and retrying the command. If the Marker field is empty, all response records have been retrieved for the request.
        public let marker: String?
        /// An OrderableClusterOption structure containing information about orderable options for the cluster.
        @OptionalCustomCoding<ArrayCoder<_OrderableClusterOptionsEncoding, OrderableClusterOption>>
        public var orderableClusterOptions: [OrderableClusterOption]?

        @inlinable
        public init(marker: String? = nil, orderableClusterOptions: [OrderableClusterOption]? = nil) {
            self.marker = marker
            self.orderableClusterOptions = orderableClusterOptions
        }

        private enum CodingKeys: String, CodingKey {
            case marker = "Marker"
            case orderableClusterOptions = "OrderableClusterOptions"
        }
    }

    public struct Parameter: AWSEncodableShape & AWSDecodableShape {
        /// The valid range of values for the parameter.
        public let allowedValues: String?
        /// Specifies how to apply the WLM configuration parameter. Some properties can be applied dynamically, while other properties require that any associated clusters be rebooted for the configuration changes to be applied.
        /// For more information about parameters and parameter groups, go to
        /// Amazon Redshift Parameter Groups
        /// in the Amazon Redshift Cluster Management Guide.
        public let applyType: ParameterApplyType?
        /// The data type of the parameter.
        public let dataType: String?
        /// A description of the parameter.
        public let description: String?
        /// If true, the parameter can be modified. Some parameters have security or operational implications that prevent them from being changed.
        public let isModifiable: Bool?
        /// The earliest engine version to which the parameter can apply.
        public let minimumEngineVersion: String?
        /// The name of the parameter.
        public let parameterName: String?
        /// The value of the parameter. If ParameterName is wlm_json_configuration,  then the maximum size of ParameterValue is 8000 characters.
        public let parameterValue: String?
        /// The source of the parameter value, such as "engine-default" or "user".
        public let source: String?

        @inlinable
        public init(allowedValues: String? = nil, applyType: ParameterApplyType? = nil, dataType: String? = nil, description: String? = nil, isModifiable: Bool? = nil, minimumEngineVersion: String? = nil, parameterName: String? = nil, parameterValue: String? = nil, source: String? = nil) {
            self.allowedValues = allowedValues
            self.applyType = applyType
            self.dataType = dataType
            self.description = description
            self.isModifiable = isModifiable
            self.minimumEngineVersion = minimumEngineVersion
            self.parameterName = parameterName
            self.parameterValue = parameterValue
            self.source = source
        }

        public func validate(name: String) throws {
            try self.validate(self.allowedValues, name: "allowedValues", parent: name, max: 2147483647)
            try self.validate(self.dataType, name: "dataType", parent: name, max: 2147483647)
            try self.validate(self.description, name: "description", parent: name, max: 2147483647)
            try self.validate(self.minimumEngineVersion, name: "minimumEngineVersion", parent: name, max: 2147483647)
            try self.validate(self.parameterName, name: "parameterName", parent: name, max: 2147483647)
            try self.validate(self.parameterValue, name: "parameterValue", parent: name, max: 2147483647)
            try self.validate(self.source, name: "source", parent: name, max: 2147483647)
        }

        private enum CodingKeys: String, CodingKey {
            case allowedValues = "AllowedValues"
            case applyType = "ApplyType"
            case dataType = "DataType"
            case description = "Description"
            case isModifiable = "IsModifiable"
            case minimumEngineVersion = "MinimumEngineVersion"
            case parameterName = "ParameterName"
            case parameterValue = "ParameterValue"
            case source = "Source"
        }
    }

    public struct PartnerIntegrationInfo: AWSDecodableShape {
        /// The date (UTC) that the partner integration was created.
        public let createdAt: Date?
        /// The name of the database that receives data from a partner.
        public let databaseName: String?
        /// The name of the partner.
        public let partnerName: String?
        /// The partner integration status.
        public let status: PartnerIntegrationStatus?
        /// The status message provided by the partner.
        public let statusMessage: String?
        /// The date (UTC) that the partner integration status was last updated by the partner.
        public let updatedAt: Date?

        @inlinable
        public init(createdAt: Date? = nil, databaseName: String? = nil, partnerName: String? = nil, status: PartnerIntegrationStatus? = nil, statusMessage: String? = nil, updatedAt: Date? = nil) {
            self.createdAt = createdAt
            self.databaseName = databaseName
            self.partnerName = partnerName
            self.status = status
            self.statusMessage = statusMessage
            self.updatedAt = updatedAt
        }

        private enum CodingKeys: String, CodingKey {
            case createdAt = "CreatedAt"
            case databaseName = "DatabaseName"
            case partnerName = "PartnerName"
            case status = "Status"
            case statusMessage = "StatusMessage"
            case updatedAt = "UpdatedAt"
        }
    }

    public struct PartnerIntegrationInputMessage: AWSEncodableShape {
        /// The Amazon Web Services account ID that owns the cluster.
        public let accountId: String?
        /// The cluster identifier of the cluster that receives data from the partner.
        public let clusterIdentifier: String?
        /// The name of the database that receives data from the partner.
        public let databaseName: String?
        /// The name of the partner that is authorized to send data.
        public let partnerName: String?

        @inlinable
        public init(accountId: String? = nil, clusterIdentifier: String? = nil, databaseName: String? = nil, partnerName: String? = nil) {
            self.accountId = accountId
            self.clusterIdentifier = clusterIdentifier
            self.databaseName = databaseName
            self.partnerName = partnerName
        }

        public func validate(name: String) throws {
            try self.validate(self.accountId, name: "accountId", parent: name, max: 12)
            try self.validate(self.accountId, name: "accountId", parent: name, min: 12)
            try self.validate(self.accountId, name: "accountId", parent: name, pattern: "^[0-9]+$")
            try self.validate(self.clusterIdentifier, name: "clusterIdentifier", parent: name, max: 63)
            try self.validate(self.clusterIdentifier, name: "clusterIdentifier", parent: name, pattern: "^[a-zA-Z0-9\\-]+$")
            try self.validate(self.databaseName, name: "databaseName", parent: name, max: 127)
            try self.validate(self.databaseName, name: "databaseName", parent: name, pattern: "^[\\p{L}_][\\p{L}\\p{N}@$#_]+$")
            try self.validate(self.partnerName, name: "partnerName", parent: name, max: 255)
            try self.validate(self.partnerName, name: "partnerName", parent: name, pattern: "^[a-zA-Z0-9\\-_]+$")
        }

        private enum CodingKeys: String, CodingKey {
            case accountId = "AccountId"
            case clusterIdentifier = "ClusterIdentifier"
            case databaseName = "DatabaseName"
            case partnerName = "PartnerName"
        }
    }

    public struct PartnerIntegrationOutputMessage: AWSDecodableShape {
        /// The name of the database that receives data from the partner.
        public let databaseName: String?
        /// The name of the partner that is authorized to send data.
        public let partnerName: String?

        @inlinable
        public init(databaseName: String? = nil, partnerName: String? = nil) {
            self.databaseName = databaseName
            self.partnerName = partnerName
        }

        private enum CodingKeys: String, CodingKey {
            case databaseName = "DatabaseName"
            case partnerName = "PartnerName"
        }
    }

    public struct PauseClusterMessage: AWSEncodableShape & AWSDecodableShape {
        /// The identifier of the cluster to be paused.
        public let clusterIdentifier: String?

        @inlinable
        public init(clusterIdentifier: String? = nil) {
            self.clusterIdentifier = clusterIdentifier
        }

        public func validate(name: String) throws {
            try self.validate(self.clusterIdentifier, name: "clusterIdentifier", parent: name, max: 2147483647)
        }

        private enum CodingKeys: String, CodingKey {
            case clusterIdentifier = "ClusterIdentifier"
        }
    }

    public struct PauseClusterResult: AWSDecodableShape {
        public let cluster: Cluster?

        @inlinable
        public init(cluster: Cluster? = nil) {
            self.cluster = cluster
        }

        private enum CodingKeys: String, CodingKey {
            case cluster = "Cluster"
        }
    }

    public struct PendingModifiedValues: AWSDecodableShape {
        /// The pending or in-progress change of the automated snapshot retention period.
        public let automatedSnapshotRetentionPeriod: Int?
        /// The pending or in-progress change of the new identifier for the cluster.
        public let clusterIdentifier: String?
        /// The pending or in-progress change of the cluster type.
        public let clusterType: String?
        /// The pending or in-progress change of the service version.
        public let clusterVersion: String?
        /// The encryption type for a cluster. Possible values are: KMS and None.
        public let encryptionType: String?
        /// An option that specifies whether to create the cluster with enhanced VPC routing enabled. To create a cluster that uses enhanced VPC routing, the cluster must be in a VPC. For more information, see Enhanced VPC Routing in the Amazon Redshift Cluster Management Guide. If this option is true, enhanced VPC routing is enabled.  Default: false
        public let enhancedVpcRouting: Bool?
        /// The name of the maintenance track that the cluster will change to during the next maintenance window.
        public let maintenanceTrackName: String?
        /// The pending or in-progress change of the admin user password for the cluster.
        public let masterUserPassword: String?
        /// The pending or in-progress change of the cluster's node type.
        public let nodeType: String?
        /// The pending or in-progress change of the number of nodes in the cluster.
        public let numberOfNodes: Int?
        /// The pending or in-progress change of the ability to connect to the cluster from the public network.
        public let publiclyAccessible: Bool?

        @inlinable
        public init(automatedSnapshotRetentionPeriod: Int? = nil, clusterIdentifier: String? = nil, clusterType: String? = nil, clusterVersion: String? = nil, encryptionType: String? = nil, enhancedVpcRouting: Bool? = nil, maintenanceTrackName: String? = nil, masterUserPassword: String? = nil, nodeType: String? = nil, numberOfNodes: Int? = nil, publiclyAccessible: Bool? = nil) {
            self.automatedSnapshotRetentionPeriod = automatedSnapshotRetentionPeriod
            self.clusterIdentifier = clusterIdentifier
            self.clusterType = clusterType
            self.clusterVersion = clusterVersion
            self.encryptionType = encryptionType
            self.enhancedVpcRouting = enhancedVpcRouting
            self.maintenanceTrackName = maintenanceTrackName
            self.masterUserPassword = masterUserPassword
            self.nodeType = nodeType
            self.numberOfNodes = numberOfNodes
            self.publiclyAccessible = publiclyAccessible
        }

        private enum CodingKeys: String, CodingKey {
            case automatedSnapshotRetentionPeriod = "AutomatedSnapshotRetentionPeriod"
            case clusterIdentifier = "ClusterIdentifier"
            case clusterType = "ClusterType"
            case clusterVersion = "ClusterVersion"
            case encryptionType = "EncryptionType"
            case enhancedVpcRouting = "EnhancedVpcRouting"
            case maintenanceTrackName = "MaintenanceTrackName"
            case masterUserPassword = "MasterUserPassword"
            case nodeType = "NodeType"
            case numberOfNodes = "NumberOfNodes"
            case publiclyAccessible = "PubliclyAccessible"
        }
    }

    public struct ProvisionedIdentifier: AWSEncodableShape {
        /// The unique identifier for the provisioned cluster.
        public let clusterIdentifier: String?

        @inlinable
        public init(clusterIdentifier: String? = nil) {
            self.clusterIdentifier = clusterIdentifier
        }

        public func validate(name: String) throws {
            try self.validate(self.clusterIdentifier, name: "clusterIdentifier", parent: name, max: 2147483647)
        }

        private enum CodingKeys: String, CodingKey {
            case clusterIdentifier = "ClusterIdentifier"
        }
    }

    public struct PurchaseReservedNodeOfferingMessage: AWSEncodableShape {
        /// The number of reserved nodes that you want to purchase. Default: 1
        public let nodeCount: Int?
        /// The unique identifier of the reserved node offering you want to purchase.
        public let reservedNodeOfferingId: String?

        @inlinable
        public init(nodeCount: Int? = nil, reservedNodeOfferingId: String? = nil) {
            self.nodeCount = nodeCount
            self.reservedNodeOfferingId = reservedNodeOfferingId
        }

        public func validate(name: String) throws {
            try self.validate(self.reservedNodeOfferingId, name: "reservedNodeOfferingId", parent: name, max: 2147483647)
        }

        private enum CodingKeys: String, CodingKey {
            case nodeCount = "NodeCount"
            case reservedNodeOfferingId = "ReservedNodeOfferingId"
        }
    }

    public struct PurchaseReservedNodeOfferingResult: AWSDecodableShape {
        public let reservedNode: ReservedNode?

        @inlinable
        public init(reservedNode: ReservedNode? = nil) {
            self.reservedNode = reservedNode
        }

        private enum CodingKeys: String, CodingKey {
            case reservedNode = "ReservedNode"
        }
    }

    public struct PutResourcePolicyMessage: AWSEncodableShape {
        /// The content of the resource policy being updated.
        public let policy: String?
        /// The Amazon Resource Name (ARN) of the resource of which its resource policy is updated.
        public let resourceArn: String?

        @inlinable
        public init(policy: String? = nil, resourceArn: String? = nil) {
            self.policy = policy
            self.resourceArn = resourceArn
        }

        public func validate(name: String) throws {
            try self.validate(self.policy, name: "policy", parent: name, max: 2147483647)
            try self.validate(self.resourceArn, name: "resourceArn", parent: name, max: 2147483647)
        }

        private enum CodingKeys: String, CodingKey {
            case policy = "Policy"
            case resourceArn = "ResourceArn"
        }
    }

    public struct PutResourcePolicyResult: AWSDecodableShape {
        /// The content of the updated resource policy.
        public let resourcePolicy: ResourcePolicy?

        @inlinable
        public init(resourcePolicy: ResourcePolicy? = nil) {
            self.resourcePolicy = resourcePolicy
        }

        private enum CodingKeys: String, CodingKey {
            case resourcePolicy = "ResourcePolicy"
        }
    }

    public struct ReadWriteAccess: AWSEncodableShape & AWSDecodableShape {
        /// Determines whether the read/write scope is enabled or disabled.
        public let authorization: ServiceAuthorization?

        @inlinable
        public init(authorization: ServiceAuthorization? = nil) {
            self.authorization = authorization
        }

        private enum CodingKeys: String, CodingKey {
            case authorization = "Authorization"
        }
    }

    public struct RebootClusterMessage: AWSEncodableShape {
        /// The cluster identifier.
        public let clusterIdentifier: String?

        @inlinable
        public init(clusterIdentifier: String? = nil) {
            self.clusterIdentifier = clusterIdentifier
        }

        public func validate(name: String) throws {
            try self.validate(self.clusterIdentifier, name: "clusterIdentifier", parent: name, max: 2147483647)
        }

        private enum CodingKeys: String, CodingKey {
            case clusterIdentifier = "ClusterIdentifier"
        }
    }

    public struct RebootClusterResult: AWSDecodableShape {
        public let cluster: Cluster?

        @inlinable
        public init(cluster: Cluster? = nil) {
            self.cluster = cluster
        }

        private enum CodingKeys: String, CodingKey {
            case cluster = "Cluster"
        }
    }

    public struct Recommendation: AWSDecodableShape {
        public struct _RecommendedActionsEncoding: ArrayCoderProperties { public static let member = "RecommendedAction" }
        public struct _ReferenceLinksEncoding: ArrayCoderProperties { public static let member = "ReferenceLink" }

        /// The unique identifier of the cluster for which the recommendation is returned.
        public let clusterIdentifier: String?
        /// The date and time (UTC) that the recommendation was created.
        public let createdAt: Date?
        /// The description of the recommendation.
        public let description: String?
        /// A unique identifier of the Advisor recommendation.
        public let id: String?
        /// The scale of the impact that the Advisor recommendation has to the performance and cost of the cluster.
        public let impactRanking: ImpactRankingType?
        /// The Amazon Redshift cluster namespace ARN for which the recommendations is returned.
        public let namespaceArn: String?
        /// The description of what was observed about your cluster.
        public let observation: String?
        /// The description of the recommendation.
        public let recommendationText: String?
        /// The type of Advisor recommendation.
        public let recommendationType: String?
        /// List of Amazon Redshift recommended actions.
        @OptionalCustomCoding<ArrayCoder<_RecommendedActionsEncoding, RecommendedAction>>
        public var recommendedActions: [RecommendedAction]?
        /// List of helpful links for more information about the Advisor recommendation.
        @OptionalCustomCoding<ArrayCoder<_ReferenceLinksEncoding, ReferenceLink>>
        public var referenceLinks: [ReferenceLink]?
        /// The title of the recommendation.
        public let title: String?

        @inlinable
        public init(clusterIdentifier: String? = nil, createdAt: Date? = nil, description: String? = nil, id: String? = nil, impactRanking: ImpactRankingType? = nil, namespaceArn: String? = nil, observation: String? = nil, recommendationText: String? = nil, recommendationType: String? = nil, recommendedActions: [RecommendedAction]? = nil, referenceLinks: [ReferenceLink]? = nil, title: String? = nil) {
            self.clusterIdentifier = clusterIdentifier
            self.createdAt = createdAt
            self.description = description
            self.id = id
            self.impactRanking = impactRanking
            self.namespaceArn = namespaceArn
            self.observation = observation
            self.recommendationText = recommendationText
            self.recommendationType = recommendationType
            self.recommendedActions = recommendedActions
            self.referenceLinks = referenceLinks
            self.title = title
        }

        private enum CodingKeys: String, CodingKey {
            case clusterIdentifier = "ClusterIdentifier"
            case createdAt = "CreatedAt"
            case description = "Description"
            case id = "Id"
            case impactRanking = "ImpactRanking"
            case namespaceArn = "NamespaceArn"
            case observation = "Observation"
            case recommendationText = "RecommendationText"
            case recommendationType = "RecommendationType"
            case recommendedActions = "RecommendedActions"
            case referenceLinks = "ReferenceLinks"
            case title = "Title"
        }
    }

    public struct RecommendedAction: AWSDecodableShape {
        /// The command to run.
        public let command: String?
        /// The database name to perform the action on. Only applicable if the type of command is SQL.
        public let database: String?
        /// The specific instruction about the command.
        public let text: String?
        /// The type of command.
        public let type: RecommendedActionType?

        @inlinable
        public init(command: String? = nil, database: String? = nil, text: String? = nil, type: RecommendedActionType? = nil) {
            self.command = command
            self.database = database
            self.text = text
            self.type = type
        }

        private enum CodingKeys: String, CodingKey {
            case command = "Command"
            case database = "Database"
            case text = "Text"
            case type = "Type"
        }
    }

    public struct RecurringCharge: AWSDecodableShape {
        /// The amount charged per the period of time specified by the recurring charge frequency.
        public let recurringChargeAmount: Double?
        /// The frequency at which the recurring charge amount is applied.
        public let recurringChargeFrequency: String?

        @inlinable
        public init(recurringChargeAmount: Double? = nil, recurringChargeFrequency: String? = nil) {
            self.recurringChargeAmount = recurringChargeAmount
            self.recurringChargeFrequency = recurringChargeFrequency
        }

        private enum CodingKeys: String, CodingKey {
            case recurringChargeAmount = "RecurringChargeAmount"
            case recurringChargeFrequency = "RecurringChargeFrequency"
        }
    }

    public struct RedshiftIdcApplication: AWSDecodableShape {
        /// The authorized token issuer list for the Amazon Redshift IAM Identity Center application.
        @OptionalCustomCoding<StandardArrayCoder<AuthorizedTokenIssuer>>
        public var authorizedTokenIssuerList: [AuthorizedTokenIssuer]?
        /// The ARN for the Amazon Redshift IAM Identity Center application. It has the required permissions to be assumed and invoke the IDC Identity Center API.
        public let iamRoleArn: String?
        /// The display name for the Amazon Redshift IAM Identity Center application. It appears on the console.
        public let idcDisplayName: String?
        /// The ARN for the IAM Identity Center instance that Redshift integrates with.
        public let idcInstanceArn: String?
        /// The ARN for the Amazon Redshift IAM Identity Center application.
        public let idcManagedApplicationArn: String?
        /// The onboarding status for the Amazon Redshift IAM Identity Center application.
        public let idcOnboardStatus: String?
        /// The identity namespace for the Amazon Redshift IAM Identity Center application. It determines which managed application verifies the connection token.
        public let identityNamespace: String?
        /// The ARN for the Redshift application that integrates with IAM Identity Center.
        public let redshiftIdcApplicationArn: String?
        /// The name of the Redshift application in IAM Identity Center.
        public let redshiftIdcApplicationName: String?
        /// A list of service integrations for the Redshift IAM Identity Center application.
        @OptionalCustomCoding<StandardArrayCoder<ServiceIntegrationsUnion>>
        public var serviceIntegrations: [ServiceIntegrationsUnion]?

        @inlinable
        public init(authorizedTokenIssuerList: [AuthorizedTokenIssuer]? = nil, iamRoleArn: String? = nil, idcDisplayName: String? = nil, idcInstanceArn: String? = nil, idcManagedApplicationArn: String? = nil, idcOnboardStatus: String? = nil, identityNamespace: String? = nil, redshiftIdcApplicationArn: String? = nil, redshiftIdcApplicationName: String? = nil, serviceIntegrations: [ServiceIntegrationsUnion]? = nil) {
            self.authorizedTokenIssuerList = authorizedTokenIssuerList
            self.iamRoleArn = iamRoleArn
            self.idcDisplayName = idcDisplayName
            self.idcInstanceArn = idcInstanceArn
            self.idcManagedApplicationArn = idcManagedApplicationArn
            self.idcOnboardStatus = idcOnboardStatus
            self.identityNamespace = identityNamespace
            self.redshiftIdcApplicationArn = redshiftIdcApplicationArn
            self.redshiftIdcApplicationName = redshiftIdcApplicationName
            self.serviceIntegrations = serviceIntegrations
        }

        private enum CodingKeys: String, CodingKey {
            case authorizedTokenIssuerList = "AuthorizedTokenIssuerList"
            case iamRoleArn = "IamRoleArn"
            case idcDisplayName = "IdcDisplayName"
            case idcInstanceArn = "IdcInstanceArn"
            case idcManagedApplicationArn = "IdcManagedApplicationArn"
            case idcOnboardStatus = "IdcOnboardStatus"
            case identityNamespace = "IdentityNamespace"
            case redshiftIdcApplicationArn = "RedshiftIdcApplicationArn"
            case redshiftIdcApplicationName = "RedshiftIdcApplicationName"
            case serviceIntegrations = "ServiceIntegrations"
        }
    }

    public struct ReferenceLink: AWSDecodableShape {
        /// The URL address to find more information.
        public let link: String?
        /// The hyperlink text that describes the link to more information.
        public let text: String?

        @inlinable
        public init(link: String? = nil, text: String? = nil) {
            self.link = link
            self.text = text
        }

        private enum CodingKeys: String, CodingKey {
            case link = "Link"
            case text = "Text"
        }
    }

    public struct RegisterNamespaceInputMessage: AWSEncodableShape {
        /// An array containing the ID of the consumer account  that you want to register the namespace to.
        @OptionalCustomCoding<StandardArrayCoder<String>>
        public var consumerIdentifiers: [String]?
        /// The unique identifier of the cluster or  serverless namespace that you want to register.
        public let namespaceIdentifier: NamespaceIdentifierUnion?

        @inlinable
        public init(consumerIdentifiers: [String]? = nil, namespaceIdentifier: NamespaceIdentifierUnion? = nil) {
            self.consumerIdentifiers = consumerIdentifiers
            self.namespaceIdentifier = namespaceIdentifier
        }

        public func validate(name: String) throws {
            try self.consumerIdentifiers?.forEach {
                try validate($0, name: "consumerIdentifiers[]", parent: name, max: 2147483647)
            }
            try self.validate(self.consumerIdentifiers, name: "consumerIdentifiers", parent: name, max: 1)
            try self.validate(self.consumerIdentifiers, name: "consumerIdentifiers", parent: name, min: 1)
            try self.namespaceIdentifier?.validate(name: "\(name).namespaceIdentifier")
        }

        private enum CodingKeys: String, CodingKey {
            case consumerIdentifiers = "ConsumerIdentifiers"
            case namespaceIdentifier = "NamespaceIdentifier"
        }
    }

    public struct RegisterNamespaceOutputMessage: AWSDecodableShape {
        /// The registration status of the cluster or  serverless namespace.
        public let status: NamespaceRegistrationStatus?

        @inlinable
        public init(status: NamespaceRegistrationStatus? = nil) {
            self.status = status
        }

        private enum CodingKeys: String, CodingKey {
            case status = "Status"
        }
    }

    public struct RejectDataShareMessage: AWSEncodableShape {
        /// The Amazon Resource Name (ARN) of the datashare to reject.
        public let dataShareArn: String?

        @inlinable
        public init(dataShareArn: String? = nil) {
            self.dataShareArn = dataShareArn
        }

        public func validate(name: String) throws {
            try self.validate(self.dataShareArn, name: "dataShareArn", parent: name, max: 2147483647)
        }

        private enum CodingKeys: String, CodingKey {
            case dataShareArn = "DataShareArn"
        }
    }

    public struct ReservedNode: AWSDecodableShape {
        public struct _RecurringChargesEncoding: ArrayCoderProperties { public static let member = "RecurringCharge" }

        /// The currency code for the reserved cluster.
        public let currencyCode: String?
        /// The duration of the node reservation in seconds.
        public let duration: Int?
        /// The fixed cost Amazon Redshift charges you for this reserved node.
        public let fixedPrice: Double?
        /// The number of reserved compute nodes.
        public let nodeCount: Int?
        /// The node type of the reserved node.
        public let nodeType: String?
        /// The anticipated utilization of the reserved node, as defined in the reserved node offering.
        public let offeringType: String?
        /// The recurring charges for the reserved node.
        @OptionalCustomCoding<ArrayCoder<_RecurringChargesEncoding, RecurringCharge>>
        public var recurringCharges: [RecurringCharge]?
        /// The unique identifier for the reservation.
        public let reservedNodeId: String?
        /// The identifier for the reserved node offering.
        public let reservedNodeOfferingId: String?
        public let reservedNodeOfferingType: ReservedNodeOfferingType?
        /// The time the reservation started. You purchase a reserved node offering for a duration. This is the start time of that duration.
        public let startTime: Date?
        /// The state of the reserved compute node. Possible Values:   pending-payment-This reserved node has recently been purchased, and the sale has been approved, but payment has not yet been confirmed.   active-This reserved node is owned by the caller and is available for use.   payment-failed-Payment failed for the purchase attempt.   retired-The reserved node is no longer available.    exchanging-The owner is exchanging the reserved node for another reserved node.
        public let state: String?
        /// The hourly rate Amazon Redshift charges you for this reserved node.
        public let usagePrice: Double?

        @inlinable
        public init(currencyCode: String? = nil, duration: Int? = nil, fixedPrice: Double? = nil, nodeCount: Int? = nil, nodeType: String? = nil, offeringType: String? = nil, recurringCharges: [RecurringCharge]? = nil, reservedNodeId: String? = nil, reservedNodeOfferingId: String? = nil, reservedNodeOfferingType: ReservedNodeOfferingType? = nil, startTime: Date? = nil, state: String? = nil, usagePrice: Double? = nil) {
            self.currencyCode = currencyCode
            self.duration = duration
            self.fixedPrice = fixedPrice
            self.nodeCount = nodeCount
            self.nodeType = nodeType
            self.offeringType = offeringType
            self.recurringCharges = recurringCharges
            self.reservedNodeId = reservedNodeId
            self.reservedNodeOfferingId = reservedNodeOfferingId
            self.reservedNodeOfferingType = reservedNodeOfferingType
            self.startTime = startTime
            self.state = state
            self.usagePrice = usagePrice
        }

        private enum CodingKeys: String, CodingKey {
            case currencyCode = "CurrencyCode"
            case duration = "Duration"
            case fixedPrice = "FixedPrice"
            case nodeCount = "NodeCount"
            case nodeType = "NodeType"
            case offeringType = "OfferingType"
            case recurringCharges = "RecurringCharges"
            case reservedNodeId = "ReservedNodeId"
            case reservedNodeOfferingId = "ReservedNodeOfferingId"
            case reservedNodeOfferingType = "ReservedNodeOfferingType"
            case startTime = "StartTime"
            case state = "State"
            case usagePrice = "UsagePrice"
        }
    }

    public struct ReservedNodeConfigurationOption: AWSDecodableShape {
        public let sourceReservedNode: ReservedNode?
        /// The target reserved-node count.
        public let targetReservedNodeCount: Int?
        public let targetReservedNodeOffering: ReservedNodeOffering?

        @inlinable
        public init(sourceReservedNode: ReservedNode? = nil, targetReservedNodeCount: Int? = nil, targetReservedNodeOffering: ReservedNodeOffering? = nil) {
            self.sourceReservedNode = sourceReservedNode
            self.targetReservedNodeCount = targetReservedNodeCount
            self.targetReservedNodeOffering = targetReservedNodeOffering
        }

        private enum CodingKeys: String, CodingKey {
            case sourceReservedNode = "SourceReservedNode"
            case targetReservedNodeCount = "TargetReservedNodeCount"
            case targetReservedNodeOffering = "TargetReservedNodeOffering"
        }
    }

    public struct ReservedNodeExchangeStatus: AWSDecodableShape {
        /// A date and time that indicate when the reserved-node exchange was requested.
        public let requestTime: Date?
        /// The identifier of the reserved-node exchange request.
        public let reservedNodeExchangeRequestId: String?
        /// The source reserved-node count in the cluster.
        public let sourceReservedNodeCount: Int?
        /// The identifier of the source reserved node.
        public let sourceReservedNodeId: String?
        /// The source reserved-node type, for example ra3.4xlarge.
        public let sourceReservedNodeType: String?
        /// The status of the reserved-node exchange request. Statuses include in-progress and requested.
        public let status: ReservedNodeExchangeStatusType?
        /// The count of target reserved nodes in the cluster.
        public let targetReservedNodeCount: Int?
        /// The identifier of the target reserved node offering.
        public let targetReservedNodeOfferingId: String?
        /// The node type of the target reserved node, for example ra3.4xlarge.
        public let targetReservedNodeType: String?

        @inlinable
        public init(requestTime: Date? = nil, reservedNodeExchangeRequestId: String? = nil, sourceReservedNodeCount: Int? = nil, sourceReservedNodeId: String? = nil, sourceReservedNodeType: String? = nil, status: ReservedNodeExchangeStatusType? = nil, targetReservedNodeCount: Int? = nil, targetReservedNodeOfferingId: String? = nil, targetReservedNodeType: String? = nil) {
            self.requestTime = requestTime
            self.reservedNodeExchangeRequestId = reservedNodeExchangeRequestId
            self.sourceReservedNodeCount = sourceReservedNodeCount
            self.sourceReservedNodeId = sourceReservedNodeId
            self.sourceReservedNodeType = sourceReservedNodeType
            self.status = status
            self.targetReservedNodeCount = targetReservedNodeCount
            self.targetReservedNodeOfferingId = targetReservedNodeOfferingId
            self.targetReservedNodeType = targetReservedNodeType
        }

        private enum CodingKeys: String, CodingKey {
            case requestTime = "RequestTime"
            case reservedNodeExchangeRequestId = "ReservedNodeExchangeRequestId"
            case sourceReservedNodeCount = "SourceReservedNodeCount"
            case sourceReservedNodeId = "SourceReservedNodeId"
            case sourceReservedNodeType = "SourceReservedNodeType"
            case status = "Status"
            case targetReservedNodeCount = "TargetReservedNodeCount"
            case targetReservedNodeOfferingId = "TargetReservedNodeOfferingId"
            case targetReservedNodeType = "TargetReservedNodeType"
        }
    }

    public struct ReservedNodeOffering: AWSDecodableShape {
        public struct _RecurringChargesEncoding: ArrayCoderProperties { public static let member = "RecurringCharge" }

        /// The currency code for the compute nodes offering.
        public let currencyCode: String?
        /// The duration, in seconds, for which the offering will reserve the node.
        public let duration: Int?
        /// The upfront fixed charge you will pay to purchase the specific reserved node offering.
        public let fixedPrice: Double?
        /// The node type offered by the reserved node offering.
        public let nodeType: String?
        /// The anticipated utilization of the reserved node, as defined in the reserved node offering.
        public let offeringType: String?
        /// The charge to your account regardless of whether you are creating any clusters using the node offering. Recurring charges are only in effect for heavy-utilization reserved nodes.
        @OptionalCustomCoding<ArrayCoder<_RecurringChargesEncoding, RecurringCharge>>
        public var recurringCharges: [RecurringCharge]?
        /// The offering identifier.
        public let reservedNodeOfferingId: String?
        public let reservedNodeOfferingType: ReservedNodeOfferingType?
        /// The rate you are charged for each hour the cluster that is using the offering is running.
        public let usagePrice: Double?

        @inlinable
        public init(currencyCode: String? = nil, duration: Int? = nil, fixedPrice: Double? = nil, nodeType: String? = nil, offeringType: String? = nil, recurringCharges: [RecurringCharge]? = nil, reservedNodeOfferingId: String? = nil, reservedNodeOfferingType: ReservedNodeOfferingType? = nil, usagePrice: Double? = nil) {
            self.currencyCode = currencyCode
            self.duration = duration
            self.fixedPrice = fixedPrice
            self.nodeType = nodeType
            self.offeringType = offeringType
            self.recurringCharges = recurringCharges
            self.reservedNodeOfferingId = reservedNodeOfferingId
            self.reservedNodeOfferingType = reservedNodeOfferingType
            self.usagePrice = usagePrice
        }

        private enum CodingKeys: String, CodingKey {
            case currencyCode = "CurrencyCode"
            case duration = "Duration"
            case fixedPrice = "FixedPrice"
            case nodeType = "NodeType"
            case offeringType = "OfferingType"
            case recurringCharges = "RecurringCharges"
            case reservedNodeOfferingId = "ReservedNodeOfferingId"
            case reservedNodeOfferingType = "ReservedNodeOfferingType"
            case usagePrice = "UsagePrice"
        }
    }

    public struct ReservedNodeOfferingsMessage: AWSDecodableShape {
        public struct _ReservedNodeOfferingsEncoding: ArrayCoderProperties { public static let member = "ReservedNodeOffering" }

        /// A value that indicates the starting point for the next set of response records in a subsequent request. If a value is returned in a response, you can retrieve the next set of records by providing this returned marker value in the Marker parameter and retrying the command. If the Marker field is empty, all response records have been retrieved for the request.
        public let marker: String?
        /// A list of ReservedNodeOffering objects.
        @OptionalCustomCoding<ArrayCoder<_ReservedNodeOfferingsEncoding, ReservedNodeOffering>>
        public var reservedNodeOfferings: [ReservedNodeOffering]?

        @inlinable
        public init(marker: String? = nil, reservedNodeOfferings: [ReservedNodeOffering]? = nil) {
            self.marker = marker
            self.reservedNodeOfferings = reservedNodeOfferings
        }

        private enum CodingKeys: String, CodingKey {
            case marker = "Marker"
            case reservedNodeOfferings = "ReservedNodeOfferings"
        }
    }

    public struct ReservedNodesMessage: AWSDecodableShape {
        public struct _ReservedNodesEncoding: ArrayCoderProperties { public static let member = "ReservedNode" }

        /// A value that indicates the starting point for the next set of response records in a subsequent request. If a value is returned in a response, you can retrieve the next set of records by providing this returned marker value in the Marker parameter and retrying the command. If the Marker field is empty, all response records have been retrieved for the request.
        public let marker: String?
        /// The list of ReservedNode objects.
        @OptionalCustomCoding<ArrayCoder<_ReservedNodesEncoding, ReservedNode>>
        public var reservedNodes: [ReservedNode]?

        @inlinable
        public init(marker: String? = nil, reservedNodes: [ReservedNode]? = nil) {
            self.marker = marker
            self.reservedNodes = reservedNodes
        }

        private enum CodingKeys: String, CodingKey {
            case marker = "Marker"
            case reservedNodes = "ReservedNodes"
        }
    }

    public struct ResetClusterParameterGroupMessage: AWSEncodableShape {
        public struct _ParametersEncoding: ArrayCoderProperties { public static let member = "Parameter" }

        /// The name of the cluster parameter group to be reset.
        public let parameterGroupName: String?
        /// An array of names of parameters to be reset. If ResetAllParameters option is not used, then at least one parameter name must be supplied.  Constraints: A maximum of 20 parameters can be reset in a single request.
        @OptionalCustomCoding<ArrayCoder<_ParametersEncoding, Parameter>>
        public var parameters: [Parameter]?
        /// If true, all parameters in the specified parameter group will be reset to their default values.  Default: true
        public let resetAllParameters: Bool?

        @inlinable
        public init(parameterGroupName: String? = nil, parameters: [Parameter]? = nil, resetAllParameters: Bool? = nil) {
            self.parameterGroupName = parameterGroupName
            self.parameters = parameters
            self.resetAllParameters = resetAllParameters
        }

        public func validate(name: String) throws {
            try self.validate(self.parameterGroupName, name: "parameterGroupName", parent: name, max: 2147483647)
            try self.parameters?.forEach {
                try $0.validate(name: "\(name).parameters[]")
            }
        }

        private enum CodingKeys: String, CodingKey {
            case parameterGroupName = "ParameterGroupName"
            case parameters = "Parameters"
            case resetAllParameters = "ResetAllParameters"
        }
    }

    public struct ResizeClusterMessage: AWSEncodableShape & AWSDecodableShape {
        /// A boolean value indicating whether the resize operation is using the classic resize process. If you don't provide this parameter or set the value to false, the resize type is elastic.
        public let classic: Bool?
        /// The unique identifier for the cluster to resize.
        public let clusterIdentifier: String?
        /// The new cluster type for the specified cluster.
        public let clusterType: String?
        /// The new node type for the nodes you are adding. If not specified, the cluster's current node type is used.
        public let nodeType: String?
        /// The new number of nodes for the cluster. If not specified, the cluster's current number of nodes is used.
        public let numberOfNodes: Int?
        /// The identifier of the reserved node.
        public let reservedNodeId: String?
        /// The identifier of the target reserved node offering.
        public let targetReservedNodeOfferingId: String?

        @inlinable
        public init(classic: Bool? = nil, clusterIdentifier: String? = nil, clusterType: String? = nil, nodeType: String? = nil, numberOfNodes: Int? = nil, reservedNodeId: String? = nil, targetReservedNodeOfferingId: String? = nil) {
            self.classic = classic
            self.clusterIdentifier = clusterIdentifier
            self.clusterType = clusterType
            self.nodeType = nodeType
            self.numberOfNodes = numberOfNodes
            self.reservedNodeId = reservedNodeId
            self.targetReservedNodeOfferingId = targetReservedNodeOfferingId
        }

        public func validate(name: String) throws {
            try self.validate(self.clusterIdentifier, name: "clusterIdentifier", parent: name, max: 2147483647)
            try self.validate(self.clusterType, name: "clusterType", parent: name, max: 2147483647)
            try self.validate(self.nodeType, name: "nodeType", parent: name, max: 2147483647)
            try self.validate(self.reservedNodeId, name: "reservedNodeId", parent: name, max: 2147483647)
            try self.validate(self.targetReservedNodeOfferingId, name: "targetReservedNodeOfferingId", parent: name, max: 2147483647)
        }

        private enum CodingKeys: String, CodingKey {
            case classic = "Classic"
            case clusterIdentifier = "ClusterIdentifier"
            case clusterType = "ClusterType"
            case nodeType = "NodeType"
            case numberOfNodes = "NumberOfNodes"
            case reservedNodeId = "ReservedNodeId"
            case targetReservedNodeOfferingId = "TargetReservedNodeOfferingId"
        }
    }

    public struct ResizeClusterResult: AWSDecodableShape {
        public let cluster: Cluster?

        @inlinable
        public init(cluster: Cluster? = nil) {
            self.cluster = cluster
        }

        private enum CodingKeys: String, CodingKey {
            case cluster = "Cluster"
        }
    }

    public struct ResizeInfo: AWSDecodableShape {
        /// A boolean value indicating if the resize operation can be cancelled.
        public let allowCancelResize: Bool?
        /// Returns the value ClassicResize.
        public let resizeType: String?

        @inlinable
        public init(allowCancelResize: Bool? = nil, resizeType: String? = nil) {
            self.allowCancelResize = allowCancelResize
            self.resizeType = resizeType
        }

        private enum CodingKeys: String, CodingKey {
            case allowCancelResize = "AllowCancelResize"
            case resizeType = "ResizeType"
        }
    }

    public struct ResizeProgressMessage: AWSDecodableShape {
        /// The average rate of the resize operation over the last few minutes, measured in megabytes per second. After the resize operation completes, this value shows the average rate of the entire resize operation.
        public let avgResizeRateInMegaBytesPerSecond: Double?
        /// The percent of data transferred from source cluster to target cluster.
        public let dataTransferProgressPercent: Double?
        /// The amount of seconds that have elapsed since the resize operation began. After the resize operation completes, this value shows the total actual time, in seconds, for the resize operation.
        public let elapsedTimeInSeconds: Int64?
        /// The estimated time remaining, in seconds, until the resize operation is complete. This value is calculated based on the average resize rate and the estimated amount of data remaining to be processed. Once the resize operation is complete, this value will be 0.
        public let estimatedTimeToCompletionInSeconds: Int64?
        /// The names of tables that have been completely imported . Valid Values: List of table names.
        @OptionalCustomCoding<StandardArrayCoder<String>>
        public var importTablesCompleted: [String]?
        /// The names of tables that are being currently imported. Valid Values: List of table names.
        @OptionalCustomCoding<StandardArrayCoder<String>>
        public var importTablesInProgress: [String]?
        /// The names of tables that have not been yet imported. Valid Values: List of table names
        @OptionalCustomCoding<StandardArrayCoder<String>>
        public var importTablesNotStarted: [String]?
        /// An optional string to provide additional details about the resize action.
        public let message: String?
        /// While the resize operation is in progress, this value shows the current amount of data, in megabytes, that has been processed so far. When the resize operation is complete, this value shows the total amount of data, in megabytes, on the cluster, which may be more or less than TotalResizeDataInMegaBytes (the estimated total amount of data before resize).
        public let progressInMegaBytes: Int64?
        /// An enum with possible values of ClassicResize and ElasticResize. These values describe the type of resize operation being performed.
        public let resizeType: String?
        /// The status of the resize operation. Valid Values: NONE | IN_PROGRESS | FAILED | SUCCEEDED | CANCELLING
        public let status: String?
        /// The cluster type after the resize operation is complete. Valid Values: multi-node | single-node
        public let targetClusterType: String?
        /// The type of encryption for the cluster after the resize is complete. Possible values are KMS and None.
        public let targetEncryptionType: String?
        /// The node type that the cluster will have after the resize operation is complete.
        public let targetNodeType: String?
        /// The number of nodes that the cluster will have after the resize operation is complete.
        public let targetNumberOfNodes: Int?
        /// The estimated total amount of data, in megabytes, on the cluster before the resize operation began.
        public let totalResizeDataInMegaBytes: Int64?

        @inlinable
        public init(avgResizeRateInMegaBytesPerSecond: Double? = nil, dataTransferProgressPercent: Double? = nil, elapsedTimeInSeconds: Int64? = nil, estimatedTimeToCompletionInSeconds: Int64? = nil, importTablesCompleted: [String]? = nil, importTablesInProgress: [String]? = nil, importTablesNotStarted: [String]? = nil, message: String? = nil, progressInMegaBytes: Int64? = nil, resizeType: String? = nil, status: String? = nil, targetClusterType: String? = nil, targetEncryptionType: String? = nil, targetNodeType: String? = nil, targetNumberOfNodes: Int? = nil, totalResizeDataInMegaBytes: Int64? = nil) {
            self.avgResizeRateInMegaBytesPerSecond = avgResizeRateInMegaBytesPerSecond
            self.dataTransferProgressPercent = dataTransferProgressPercent
            self.elapsedTimeInSeconds = elapsedTimeInSeconds
            self.estimatedTimeToCompletionInSeconds = estimatedTimeToCompletionInSeconds
            self.importTablesCompleted = importTablesCompleted
            self.importTablesInProgress = importTablesInProgress
            self.importTablesNotStarted = importTablesNotStarted
            self.message = message
            self.progressInMegaBytes = progressInMegaBytes
            self.resizeType = resizeType
            self.status = status
            self.targetClusterType = targetClusterType
            self.targetEncryptionType = targetEncryptionType
            self.targetNodeType = targetNodeType
            self.targetNumberOfNodes = targetNumberOfNodes
            self.totalResizeDataInMegaBytes = totalResizeDataInMegaBytes
        }

        private enum CodingKeys: String, CodingKey {
            case avgResizeRateInMegaBytesPerSecond = "AvgResizeRateInMegaBytesPerSecond"
            case dataTransferProgressPercent = "DataTransferProgressPercent"
            case elapsedTimeInSeconds = "ElapsedTimeInSeconds"
            case estimatedTimeToCompletionInSeconds = "EstimatedTimeToCompletionInSeconds"
            case importTablesCompleted = "ImportTablesCompleted"
            case importTablesInProgress = "ImportTablesInProgress"
            case importTablesNotStarted = "ImportTablesNotStarted"
            case message = "Message"
            case progressInMegaBytes = "ProgressInMegaBytes"
            case resizeType = "ResizeType"
            case status = "Status"
            case targetClusterType = "TargetClusterType"
            case targetEncryptionType = "TargetEncryptionType"
            case targetNodeType = "TargetNodeType"
            case targetNumberOfNodes = "TargetNumberOfNodes"
            case totalResizeDataInMegaBytes = "TotalResizeDataInMegaBytes"
        }
    }

    public struct ResourcePolicy: AWSDecodableShape {
        /// The content of a resource policy.
        public let policy: String?
        /// The resources that a policy is attached to.
        public let resourceArn: String?

        @inlinable
        public init(policy: String? = nil, resourceArn: String? = nil) {
            self.policy = policy
            self.resourceArn = resourceArn
        }

        private enum CodingKeys: String, CodingKey {
            case policy = "Policy"
            case resourceArn = "ResourceArn"
        }
    }

    public struct RestoreFromClusterSnapshotMessage: AWSEncodableShape {
        public struct _ClusterSecurityGroupsEncoding: ArrayCoderProperties { public static let member = "ClusterSecurityGroupName" }
        public struct _IamRolesEncoding: ArrayCoderProperties { public static let member = "IamRoleArn" }
        public struct _VpcSecurityGroupIdsEncoding: ArrayCoderProperties { public static let member = "VpcSecurityGroupId" }

        /// Reserved.
        public let additionalInfo: String?
        /// If true, major version upgrades can be applied during the maintenance window to the Amazon Redshift engine that is running on the cluster.  Default: true
        public let allowVersionUpgrade: Bool?
        /// This parameter is retired. It does not set the AQUA configuration status. Amazon Redshift automatically determines whether to use AQUA (Advanced Query Accelerator).
        public let aquaConfigurationStatus: AquaConfigurationStatus?
        /// The number of days that automated snapshots are retained. If the value is 0, automated snapshots are disabled. Even if automated snapshots are disabled, you can still create manual snapshots when you want with CreateClusterSnapshot.  You can't disable automated snapshots for RA3 node types. Set the automated retention period from 1-35 days. Default: The value selected for the cluster from which the snapshot was taken. Constraints: Must be a value from 0 to 35.
        public let automatedSnapshotRetentionPeriod: Int?
        /// The Amazon EC2 Availability Zone in which to restore the cluster. Default: A random, system-chosen Availability Zone. Example: us-east-2a
        public let availabilityZone: String?
        /// The option to enable relocation for an Amazon Redshift cluster between Availability Zones after the cluster is restored.
        public let availabilityZoneRelocation: Bool?
        /// The identifier of the cluster that will be created from restoring the snapshot. Constraints:   Must contain from 1 to 63 alphanumeric characters or hyphens.   Alphabetic characters must be lowercase.   First character must be a letter.   Cannot end with a hyphen or contain two consecutive hyphens.   Must be unique for all clusters within an Amazon Web Services account.
        public let clusterIdentifier: String?
        /// The name of the parameter group to be associated with this cluster. Default: The default Amazon Redshift cluster parameter group. For information about the default parameter group, go to Working with Amazon Redshift Parameter Groups. Constraints:   Must be 1 to 255 alphanumeric characters or hyphens.   First character must be a letter.   Cannot end with a hyphen or contain two consecutive hyphens.
        public let clusterParameterGroupName: String?
        /// A list of security groups to be associated with this cluster. Default: The default cluster security group for Amazon Redshift. Cluster security groups only apply to clusters outside of VPCs.
        @OptionalCustomCoding<ArrayCoder<_ClusterSecurityGroupsEncoding, String>>
        public var clusterSecurityGroups: [String]?
        /// The name of the subnet group where you want to cluster restored. A snapshot of cluster in VPC can be restored only in VPC. Therefore, you must provide subnet group name where you want the cluster restored.
        public let clusterSubnetGroupName: String?
        /// The Amazon Resource Name (ARN) for the IAM role that was set as default for the cluster when the cluster was last modified while it was restored from a snapshot.
        public let defaultIamRoleArn: String?
        /// The Elastic IP (EIP) address for the cluster. Don't specify the Elastic IP address for a publicly  accessible cluster with availability zone relocation turned on.
        public let elasticIp: String?
        /// Enables support for restoring an unencrypted snapshot to a cluster encrypted  with Key Management Service (KMS) and a customer managed key.
        public let encrypted: Bool?
        /// An option that specifies whether to create the cluster with enhanced VPC routing enabled. To create a cluster that uses enhanced VPC routing, the cluster must be in a VPC. For more information, see Enhanced VPC Routing in the Amazon Redshift Cluster Management Guide. If this option is true, enhanced VPC routing is enabled.  Default: false
        public let enhancedVpcRouting: Bool?
        /// Specifies the name of the HSM client certificate the Amazon Redshift cluster uses to retrieve the data encryption keys stored in an HSM.
        public let hsmClientCertificateIdentifier: String?
        /// Specifies the name of the HSM configuration that contains the information the Amazon Redshift cluster can use to retrieve and store keys in an HSM.
        public let hsmConfigurationIdentifier: String?
        /// A list of Identity and Access Management (IAM) roles that can be used by the cluster to access other Amazon Web Services services. You must supply the IAM roles in their Amazon Resource Name (ARN) format.  The maximum number of IAM roles that you can associate is subject to a quota. For more information, go to Quotas and limits in the Amazon Redshift Cluster Management Guide.
        @OptionalCustomCoding<ArrayCoder<_IamRolesEncoding, String>>
        public var iamRoles: [String]?
        /// The IP address type for the cluster. Possible values are ipv4 and dualstack.
        public let ipAddressType: String?
        /// The Key Management Service (KMS) key ID of the encryption key that encrypts data in the cluster  restored from a shared snapshot. You can also provide  the key ID when you restore from an unencrypted snapshot to an encrypted cluster in  the same account. Additionally, you can specify a new KMS key ID when you restore from an encrypted  snapshot in the same account in order to change it. In that case, the restored cluster is encrypted  with the new KMS key ID.
        public let kmsKeyId: String?
        /// The name of the maintenance track for the restored cluster. When you take a snapshot, the snapshot inherits the MaintenanceTrack value from the cluster. The snapshot might be on a different track than the cluster that was the source for the snapshot. For example, suppose that you take a snapshot of a cluster that is on the current track and then change the cluster to be on the trailing track. In this case, the snapshot and the source cluster are on different tracks.
        public let maintenanceTrackName: String?
        /// If true, Amazon Redshift uses Secrets Manager to manage the restored  cluster's admin credentials. If ManageMasterPassword is false or not set,  Amazon Redshift uses the admin credentials the cluster had at the time the snapshot was taken.
        public let manageMasterPassword: Bool?
        /// The default number of days to retain a manual snapshot. If the value is -1, the snapshot is retained indefinitely. This setting doesn't change the retention period of existing snapshots. The value must be either -1 or an integer between 1 and 3,653.
        public let manualSnapshotRetentionPeriod: Int?
        /// The ID of the Key Management Service (KMS) key used to encrypt and store the cluster's admin credentials secret.  You can only use this parameter if ManageMasterPassword is true.
        public let masterPasswordSecretKmsKeyId: String?
        /// If true, the snapshot will be restored to a cluster deployed in two Availability Zones.
        public let multiAZ: Bool?
        /// The node type that the restored cluster will be provisioned with. If you have a DC instance type, you must restore into that same instance type and size. In other words, you can only restore a dc2.large node type into another dc2 type. For more information about node types, see   About Clusters and Nodes in the Amazon Redshift Cluster Management Guide.
        public let nodeType: String?
        /// The number of nodes specified when provisioning the restored cluster.
        public let numberOfNodes: Int?
        /// The Amazon Web Services account used to create or copy the snapshot. Required if you are restoring a snapshot you do not own, optional if you own the snapshot.
        public let ownerAccount: String?
        /// The port number on which the cluster accepts connections. Default: The same port as the original cluster. Valid values: For clusters with DC2 nodes, must be within the range 1150-65535. For clusters with ra3 nodes, must be  within the ranges 5431-5455 or 8191-8215.
        public let port: Int?
        /// The weekly time range (in UTC) during which automated cluster maintenance can occur. Format: ddd:hh24:mi-ddd:hh24:mi  Default: The value selected for the cluster from which the snapshot was taken. For more information about the time blocks for each region, see Maintenance Windows in Amazon Redshift Cluster Management Guide.  Valid Days: Mon | Tue | Wed | Thu | Fri | Sat | Sun Constraints: Minimum 30-minute window.
        public let preferredMaintenanceWindow: String?
        /// If true, the cluster can be accessed from a public network.  Default: false
        public let publiclyAccessible: Bool?
        /// The identifier of the target reserved node offering.
        public let reservedNodeId: String?
        /// The Amazon Resource Name (ARN) of the snapshot associated with the message to restore from a cluster. You must specify this parameter or snapshotIdentifier, but not both.
        public let snapshotArn: String?
        /// The name of the cluster the source snapshot was created from. This parameter is required if your IAM user has a policy containing a snapshot resource element that specifies anything other than * for the cluster name.
        public let snapshotClusterIdentifier: String?
        /// The name of the snapshot from which to create the new cluster. This parameter isn't case sensitive. You must specify this parameter or snapshotArn, but not both. Example: my-snapshot-id
        public let snapshotIdentifier: String?
        /// A unique identifier for the snapshot schedule.
        public let snapshotScheduleIdentifier: String?
        /// The identifier of the target reserved node offering.
        public let targetReservedNodeOfferingId: String?
        /// A list of Virtual Private Cloud (VPC) security groups to be associated with the cluster. Default: The default VPC security group is associated with the cluster. VPC security groups only apply to clusters in VPCs.
        @OptionalCustomCoding<ArrayCoder<_VpcSecurityGroupIdsEncoding, String>>
        public var vpcSecurityGroupIds: [String]?

        @inlinable
        public init(additionalInfo: String? = nil, allowVersionUpgrade: Bool? = nil, aquaConfigurationStatus: AquaConfigurationStatus? = nil, automatedSnapshotRetentionPeriod: Int? = nil, availabilityZone: String? = nil, availabilityZoneRelocation: Bool? = nil, clusterIdentifier: String? = nil, clusterParameterGroupName: String? = nil, clusterSecurityGroups: [String]? = nil, clusterSubnetGroupName: String? = nil, defaultIamRoleArn: String? = nil, elasticIp: String? = nil, encrypted: Bool? = nil, enhancedVpcRouting: Bool? = nil, hsmClientCertificateIdentifier: String? = nil, hsmConfigurationIdentifier: String? = nil, iamRoles: [String]? = nil, ipAddressType: String? = nil, kmsKeyId: String? = nil, maintenanceTrackName: String? = nil, manageMasterPassword: Bool? = nil, manualSnapshotRetentionPeriod: Int? = nil, masterPasswordSecretKmsKeyId: String? = nil, multiAZ: Bool? = nil, nodeType: String? = nil, numberOfNodes: Int? = nil, ownerAccount: String? = nil, port: Int? = nil, preferredMaintenanceWindow: String? = nil, publiclyAccessible: Bool? = nil, reservedNodeId: String? = nil, snapshotArn: String? = nil, snapshotClusterIdentifier: String? = nil, snapshotIdentifier: String? = nil, snapshotScheduleIdentifier: String? = nil, targetReservedNodeOfferingId: String? = nil, vpcSecurityGroupIds: [String]? = nil) {
            self.additionalInfo = additionalInfo
            self.allowVersionUpgrade = allowVersionUpgrade
            self.aquaConfigurationStatus = aquaConfigurationStatus
            self.automatedSnapshotRetentionPeriod = automatedSnapshotRetentionPeriod
            self.availabilityZone = availabilityZone
            self.availabilityZoneRelocation = availabilityZoneRelocation
            self.clusterIdentifier = clusterIdentifier
            self.clusterParameterGroupName = clusterParameterGroupName
            self.clusterSecurityGroups = clusterSecurityGroups
            self.clusterSubnetGroupName = clusterSubnetGroupName
            self.defaultIamRoleArn = defaultIamRoleArn
            self.elasticIp = elasticIp
            self.encrypted = encrypted
            self.enhancedVpcRouting = enhancedVpcRouting
            self.hsmClientCertificateIdentifier = hsmClientCertificateIdentifier
            self.hsmConfigurationIdentifier = hsmConfigurationIdentifier
            self.iamRoles = iamRoles
            self.ipAddressType = ipAddressType
            self.kmsKeyId = kmsKeyId
            self.maintenanceTrackName = maintenanceTrackName
            self.manageMasterPassword = manageMasterPassword
            self.manualSnapshotRetentionPeriod = manualSnapshotRetentionPeriod
            self.masterPasswordSecretKmsKeyId = masterPasswordSecretKmsKeyId
            self.multiAZ = multiAZ
            self.nodeType = nodeType
            self.numberOfNodes = numberOfNodes
            self.ownerAccount = ownerAccount
            self.port = port
            self.preferredMaintenanceWindow = preferredMaintenanceWindow
            self.publiclyAccessible = publiclyAccessible
            self.reservedNodeId = reservedNodeId
            self.snapshotArn = snapshotArn
            self.snapshotClusterIdentifier = snapshotClusterIdentifier
            self.snapshotIdentifier = snapshotIdentifier
            self.snapshotScheduleIdentifier = snapshotScheduleIdentifier
            self.targetReservedNodeOfferingId = targetReservedNodeOfferingId
            self.vpcSecurityGroupIds = vpcSecurityGroupIds
        }

        public func validate(name: String) throws {
            try self.validate(self.additionalInfo, name: "additionalInfo", parent: name, max: 2147483647)
            try self.validate(self.availabilityZone, name: "availabilityZone", parent: name, max: 2147483647)
            try self.validate(self.clusterIdentifier, name: "clusterIdentifier", parent: name, max: 2147483647)
            try self.validate(self.clusterParameterGroupName, name: "clusterParameterGroupName", parent: name, max: 2147483647)
            try self.clusterSecurityGroups?.forEach {
                try validate($0, name: "clusterSecurityGroups[]", parent: name, max: 2147483647)
            }
            try self.validate(self.clusterSubnetGroupName, name: "clusterSubnetGroupName", parent: name, max: 2147483647)
            try self.validate(self.defaultIamRoleArn, name: "defaultIamRoleArn", parent: name, max: 2147483647)
            try self.validate(self.elasticIp, name: "elasticIp", parent: name, max: 2147483647)
            try self.validate(self.hsmClientCertificateIdentifier, name: "hsmClientCertificateIdentifier", parent: name, max: 2147483647)
            try self.validate(self.hsmConfigurationIdentifier, name: "hsmConfigurationIdentifier", parent: name, max: 2147483647)
            try self.iamRoles?.forEach {
                try validate($0, name: "iamRoles[]", parent: name, max: 2147483647)
            }
            try self.validate(self.ipAddressType, name: "ipAddressType", parent: name, max: 2147483647)
            try self.validate(self.kmsKeyId, name: "kmsKeyId", parent: name, max: 2147483647)
            try self.validate(self.maintenanceTrackName, name: "maintenanceTrackName", parent: name, max: 2147483647)
            try self.validate(self.masterPasswordSecretKmsKeyId, name: "masterPasswordSecretKmsKeyId", parent: name, max: 2147483647)
            try self.validate(self.nodeType, name: "nodeType", parent: name, max: 2147483647)
            try self.validate(self.ownerAccount, name: "ownerAccount", parent: name, max: 2147483647)
            try self.validate(self.preferredMaintenanceWindow, name: "preferredMaintenanceWindow", parent: name, max: 2147483647)
            try self.validate(self.reservedNodeId, name: "reservedNodeId", parent: name, max: 2147483647)
            try self.validate(self.snapshotArn, name: "snapshotArn", parent: name, max: 2147483647)
            try self.validate(self.snapshotClusterIdentifier, name: "snapshotClusterIdentifier", parent: name, max: 2147483647)
            try self.validate(self.snapshotIdentifier, name: "snapshotIdentifier", parent: name, max: 2147483647)
            try self.validate(self.snapshotScheduleIdentifier, name: "snapshotScheduleIdentifier", parent: name, max: 2147483647)
            try self.validate(self.targetReservedNodeOfferingId, name: "targetReservedNodeOfferingId", parent: name, max: 2147483647)
            try self.vpcSecurityGroupIds?.forEach {
                try validate($0, name: "vpcSecurityGroupIds[]", parent: name, max: 2147483647)
            }
        }

        private enum CodingKeys: String, CodingKey {
            case additionalInfo = "AdditionalInfo"
            case allowVersionUpgrade = "AllowVersionUpgrade"
            case aquaConfigurationStatus = "AquaConfigurationStatus"
            case automatedSnapshotRetentionPeriod = "AutomatedSnapshotRetentionPeriod"
            case availabilityZone = "AvailabilityZone"
            case availabilityZoneRelocation = "AvailabilityZoneRelocation"
            case clusterIdentifier = "ClusterIdentifier"
            case clusterParameterGroupName = "ClusterParameterGroupName"
            case clusterSecurityGroups = "ClusterSecurityGroups"
            case clusterSubnetGroupName = "ClusterSubnetGroupName"
            case defaultIamRoleArn = "DefaultIamRoleArn"
            case elasticIp = "ElasticIp"
            case encrypted = "Encrypted"
            case enhancedVpcRouting = "EnhancedVpcRouting"
            case hsmClientCertificateIdentifier = "HsmClientCertificateIdentifier"
            case hsmConfigurationIdentifier = "HsmConfigurationIdentifier"
            case iamRoles = "IamRoles"
            case ipAddressType = "IpAddressType"
            case kmsKeyId = "KmsKeyId"
            case maintenanceTrackName = "MaintenanceTrackName"
            case manageMasterPassword = "ManageMasterPassword"
            case manualSnapshotRetentionPeriod = "ManualSnapshotRetentionPeriod"
            case masterPasswordSecretKmsKeyId = "MasterPasswordSecretKmsKeyId"
            case multiAZ = "MultiAZ"
            case nodeType = "NodeType"
            case numberOfNodes = "NumberOfNodes"
            case ownerAccount = "OwnerAccount"
            case port = "Port"
            case preferredMaintenanceWindow = "PreferredMaintenanceWindow"
            case publiclyAccessible = "PubliclyAccessible"
            case reservedNodeId = "ReservedNodeId"
            case snapshotArn = "SnapshotArn"
            case snapshotClusterIdentifier = "SnapshotClusterIdentifier"
            case snapshotIdentifier = "SnapshotIdentifier"
            case snapshotScheduleIdentifier = "SnapshotScheduleIdentifier"
            case targetReservedNodeOfferingId = "TargetReservedNodeOfferingId"
            case vpcSecurityGroupIds = "VpcSecurityGroupIds"
        }
    }

    public struct RestoreFromClusterSnapshotResult: AWSDecodableShape {
        public let cluster: Cluster?

        @inlinable
        public init(cluster: Cluster? = nil) {
            self.cluster = cluster
        }

        private enum CodingKeys: String, CodingKey {
            case cluster = "Cluster"
        }
    }

    public struct RestoreStatus: AWSDecodableShape {
        /// The number of megabytes per second being transferred from the backup storage. Returns the average rate for a completed backup. This field is only updated when you restore to DC2 node types.
        public let currentRestoreRateInMegaBytesPerSecond: Double?
        /// The amount of time an in-progress restore has been running, or the amount of time it took a completed restore to finish. This field is only updated when you restore to DC2 node types.
        public let elapsedTimeInSeconds: Int64?
        /// The estimate of the time remaining before the restore will complete. Returns 0 for a completed restore. This field is only updated when you restore to DC2 node types.
        public let estimatedTimeToCompletionInSeconds: Int64?
        /// The number of megabytes that have been transferred from snapshot storage. This field is only updated when you restore to DC2 node types.
        public let progressInMegaBytes: Int64?
        /// The size of the set of snapshot data used to restore the cluster. This field is only updated when you restore to DC2 node types.
        public let snapshotSizeInMegaBytes: Int64?
        /// The status of the restore action. Returns starting, restoring, completed, or failed.
        public let status: String?

        @inlinable
        public init(currentRestoreRateInMegaBytesPerSecond: Double? = nil, elapsedTimeInSeconds: Int64? = nil, estimatedTimeToCompletionInSeconds: Int64? = nil, progressInMegaBytes: Int64? = nil, snapshotSizeInMegaBytes: Int64? = nil, status: String? = nil) {
            self.currentRestoreRateInMegaBytesPerSecond = currentRestoreRateInMegaBytesPerSecond
            self.elapsedTimeInSeconds = elapsedTimeInSeconds
            self.estimatedTimeToCompletionInSeconds = estimatedTimeToCompletionInSeconds
            self.progressInMegaBytes = progressInMegaBytes
            self.snapshotSizeInMegaBytes = snapshotSizeInMegaBytes
            self.status = status
        }

        private enum CodingKeys: String, CodingKey {
            case currentRestoreRateInMegaBytesPerSecond = "CurrentRestoreRateInMegaBytesPerSecond"
            case elapsedTimeInSeconds = "ElapsedTimeInSeconds"
            case estimatedTimeToCompletionInSeconds = "EstimatedTimeToCompletionInSeconds"
            case progressInMegaBytes = "ProgressInMegaBytes"
            case snapshotSizeInMegaBytes = "SnapshotSizeInMegaBytes"
            case status = "Status"
        }
    }

    public struct RestoreTableFromClusterSnapshotMessage: AWSEncodableShape {
        /// The identifier of the Amazon Redshift cluster to restore the table to.
        public let clusterIdentifier: String?
        /// Indicates whether name identifiers for database, schema, and table are case sensitive.  If true, the names are case sensitive.  If false (default), the names are not case sensitive.
        public let enableCaseSensitiveIdentifier: Bool?
        /// The name of the table to create as a result of the current request.
        public let newTableName: String?
        /// The identifier of the snapshot to restore the table from. This snapshot must have been created from the Amazon Redshift cluster specified by the ClusterIdentifier parameter.
        public let snapshotIdentifier: String?
        /// The name of the source database that contains the table to restore from.
        public let sourceDatabaseName: String?
        /// The name of the source schema that contains the table to restore from. If you do not specify a SourceSchemaName value, the default is public.
        public let sourceSchemaName: String?
        /// The name of the source table to restore from.
        public let sourceTableName: String?
        /// The name of the database to restore the table to.
        public let targetDatabaseName: String?
        /// The name of the schema to restore the table to.
        public let targetSchemaName: String?

        @inlinable
        public init(clusterIdentifier: String? = nil, enableCaseSensitiveIdentifier: Bool? = nil, newTableName: String? = nil, snapshotIdentifier: String? = nil, sourceDatabaseName: String? = nil, sourceSchemaName: String? = nil, sourceTableName: String? = nil, targetDatabaseName: String? = nil, targetSchemaName: String? = nil) {
            self.clusterIdentifier = clusterIdentifier
            self.enableCaseSensitiveIdentifier = enableCaseSensitiveIdentifier
            self.newTableName = newTableName
            self.snapshotIdentifier = snapshotIdentifier
            self.sourceDatabaseName = sourceDatabaseName
            self.sourceSchemaName = sourceSchemaName
            self.sourceTableName = sourceTableName
            self.targetDatabaseName = targetDatabaseName
            self.targetSchemaName = targetSchemaName
        }

        public func validate(name: String) throws {
            try self.validate(self.clusterIdentifier, name: "clusterIdentifier", parent: name, max: 2147483647)
            try self.validate(self.newTableName, name: "newTableName", parent: name, max: 2147483647)
            try self.validate(self.snapshotIdentifier, name: "snapshotIdentifier", parent: name, max: 2147483647)
            try self.validate(self.sourceDatabaseName, name: "sourceDatabaseName", parent: name, max: 2147483647)
            try self.validate(self.sourceSchemaName, name: "sourceSchemaName", parent: name, max: 2147483647)
            try self.validate(self.sourceTableName, name: "sourceTableName", parent: name, max: 2147483647)
            try self.validate(self.targetDatabaseName, name: "targetDatabaseName", parent: name, max: 2147483647)
            try self.validate(self.targetSchemaName, name: "targetSchemaName", parent: name, max: 2147483647)
        }

        private enum CodingKeys: String, CodingKey {
            case clusterIdentifier = "ClusterIdentifier"
            case enableCaseSensitiveIdentifier = "EnableCaseSensitiveIdentifier"
            case newTableName = "NewTableName"
            case snapshotIdentifier = "SnapshotIdentifier"
            case sourceDatabaseName = "SourceDatabaseName"
            case sourceSchemaName = "SourceSchemaName"
            case sourceTableName = "SourceTableName"
            case targetDatabaseName = "TargetDatabaseName"
            case targetSchemaName = "TargetSchemaName"
        }
    }

    public struct RestoreTableFromClusterSnapshotResult: AWSDecodableShape {
        public let tableRestoreStatus: TableRestoreStatus?

        @inlinable
        public init(tableRestoreStatus: TableRestoreStatus? = nil) {
            self.tableRestoreStatus = tableRestoreStatus
        }

        private enum CodingKeys: String, CodingKey {
            case tableRestoreStatus = "TableRestoreStatus"
        }
    }

    public struct ResumeClusterMessage: AWSEncodableShape & AWSDecodableShape {
        /// The identifier of the cluster to be resumed.
        public let clusterIdentifier: String?

        @inlinable
        public init(clusterIdentifier: String? = nil) {
            self.clusterIdentifier = clusterIdentifier
        }

        public func validate(name: String) throws {
            try self.validate(self.clusterIdentifier, name: "clusterIdentifier", parent: name, max: 2147483647)
        }

        private enum CodingKeys: String, CodingKey {
            case clusterIdentifier = "ClusterIdentifier"
        }
    }

    public struct ResumeClusterResult: AWSDecodableShape {
        public let cluster: Cluster?

        @inlinable
        public init(cluster: Cluster? = nil) {
            self.cluster = cluster
        }

        private enum CodingKeys: String, CodingKey {
            case cluster = "Cluster"
        }
    }

    public struct RevisionTarget: AWSDecodableShape {
        /// A unique string that identifies the version to update the cluster to. You can use this value in ModifyClusterDbRevision.
        public let databaseRevision: String?
        /// The date on which the database revision was released.
        public let databaseRevisionReleaseDate: Date?
        /// A string that describes the changes and features that will be applied to the cluster when it is updated to the corresponding ClusterDbRevision.
        public let description: String?

        @inlinable
        public init(databaseRevision: String? = nil, databaseRevisionReleaseDate: Date? = nil, description: String? = nil) {
            self.databaseRevision = databaseRevision
            self.databaseRevisionReleaseDate = databaseRevisionReleaseDate
            self.description = description
        }

        private enum CodingKeys: String, CodingKey {
            case databaseRevision = "DatabaseRevision"
            case databaseRevisionReleaseDate = "DatabaseRevisionReleaseDate"
            case description = "Description"
        }
    }

    public struct RevokeClusterSecurityGroupIngressMessage: AWSEncodableShape {
        /// The IP range for which to revoke access. This range must be a valid Classless Inter-Domain Routing (CIDR) block of IP addresses. If CIDRIP is specified, EC2SecurityGroupName and EC2SecurityGroupOwnerId cannot be provided.
        public let cidrip: String?
        /// The name of the security Group from which to revoke the ingress rule.
        public let clusterSecurityGroupName: String?
        /// The name of the EC2 Security Group whose access is to be revoked. If EC2SecurityGroupName is specified, EC2SecurityGroupOwnerId must also be provided and CIDRIP cannot be provided.
        public let ec2SecurityGroupName: String?
        /// The Amazon Web Services account number of the owner of the security group specified in the EC2SecurityGroupName parameter. The Amazon Web Services access key ID is not an acceptable value. If EC2SecurityGroupOwnerId is specified, EC2SecurityGroupName must also be provided. and CIDRIP cannot be provided.  Example: 111122223333
        public let ec2SecurityGroupOwnerId: String?

        @inlinable
        public init(cidrip: String? = nil, clusterSecurityGroupName: String? = nil, ec2SecurityGroupName: String? = nil, ec2SecurityGroupOwnerId: String? = nil) {
            self.cidrip = cidrip
            self.clusterSecurityGroupName = clusterSecurityGroupName
            self.ec2SecurityGroupName = ec2SecurityGroupName
            self.ec2SecurityGroupOwnerId = ec2SecurityGroupOwnerId
        }

        public func validate(name: String) throws {
            try self.validate(self.cidrip, name: "cidrip", parent: name, max: 2147483647)
            try self.validate(self.clusterSecurityGroupName, name: "clusterSecurityGroupName", parent: name, max: 2147483647)
            try self.validate(self.ec2SecurityGroupName, name: "ec2SecurityGroupName", parent: name, max: 2147483647)
            try self.validate(self.ec2SecurityGroupOwnerId, name: "ec2SecurityGroupOwnerId", parent: name, max: 2147483647)
        }

        private enum CodingKeys: String, CodingKey {
            case cidrip = "CIDRIP"
            case clusterSecurityGroupName = "ClusterSecurityGroupName"
            case ec2SecurityGroupName = "EC2SecurityGroupName"
            case ec2SecurityGroupOwnerId = "EC2SecurityGroupOwnerId"
        }
    }

    public struct RevokeClusterSecurityGroupIngressResult: AWSDecodableShape {
        public let clusterSecurityGroup: ClusterSecurityGroup?

        @inlinable
        public init(clusterSecurityGroup: ClusterSecurityGroup? = nil) {
            self.clusterSecurityGroup = clusterSecurityGroup
        }

        private enum CodingKeys: String, CodingKey {
            case clusterSecurityGroup = "ClusterSecurityGroup"
        }
    }

    public struct RevokeEndpointAccessMessage: AWSEncodableShape {
        public struct _VpcIdsEncoding: ArrayCoderProperties { public static let member = "VpcIdentifier" }

        /// The Amazon Web Services account ID whose access is to be revoked.
        public let account: String?
        /// The cluster to revoke access from.
        public let clusterIdentifier: String?
        /// Indicates whether to force the revoke action.  If true, the Redshift-managed VPC endpoints associated with the endpoint authorization are also deleted.
        public let force: Bool?
        /// The virtual private cloud (VPC) identifiers for which access is to be revoked.
        @OptionalCustomCoding<ArrayCoder<_VpcIdsEncoding, String>>
        public var vpcIds: [String]?

        @inlinable
        public init(account: String? = nil, clusterIdentifier: String? = nil, force: Bool? = nil, vpcIds: [String]? = nil) {
            self.account = account
            self.clusterIdentifier = clusterIdentifier
            self.force = force
            self.vpcIds = vpcIds
        }

        public func validate(name: String) throws {
            try self.validate(self.account, name: "account", parent: name, max: 2147483647)
            try self.validate(self.clusterIdentifier, name: "clusterIdentifier", parent: name, max: 2147483647)
            try self.vpcIds?.forEach {
                try validate($0, name: "vpcIds[]", parent: name, max: 2147483647)
            }
        }

        private enum CodingKeys: String, CodingKey {
            case account = "Account"
            case clusterIdentifier = "ClusterIdentifier"
            case force = "Force"
            case vpcIds = "VpcIds"
        }
    }

    public struct RevokeSnapshotAccessMessage: AWSEncodableShape {
        /// The identifier of the Amazon Web Services account that can no longer restore the specified snapshot.
        public let accountWithRestoreAccess: String?
        /// The Amazon Resource Name (ARN) of the snapshot associated with the message to revoke access.
        public let snapshotArn: String?
        /// The identifier of the cluster the snapshot was created from. This parameter is required if your IAM user has a policy containing a snapshot resource element that specifies anything other than * for the cluster name.
        public let snapshotClusterIdentifier: String?
        /// The identifier of the snapshot that the account can no longer access.
        public let snapshotIdentifier: String?

        @inlinable
        public init(accountWithRestoreAccess: String? = nil, snapshotArn: String? = nil, snapshotClusterIdentifier: String? = nil, snapshotIdentifier: String? = nil) {
            self.accountWithRestoreAccess = accountWithRestoreAccess
            self.snapshotArn = snapshotArn
            self.snapshotClusterIdentifier = snapshotClusterIdentifier
            self.snapshotIdentifier = snapshotIdentifier
        }

        public func validate(name: String) throws {
            try self.validate(self.accountWithRestoreAccess, name: "accountWithRestoreAccess", parent: name, max: 2147483647)
            try self.validate(self.snapshotArn, name: "snapshotArn", parent: name, max: 2147483647)
            try self.validate(self.snapshotClusterIdentifier, name: "snapshotClusterIdentifier", parent: name, max: 2147483647)
            try self.validate(self.snapshotIdentifier, name: "snapshotIdentifier", parent: name, max: 2147483647)
        }

        private enum CodingKeys: String, CodingKey {
            case accountWithRestoreAccess = "AccountWithRestoreAccess"
            case snapshotArn = "SnapshotArn"
            case snapshotClusterIdentifier = "SnapshotClusterIdentifier"
            case snapshotIdentifier = "SnapshotIdentifier"
        }
    }

    public struct RevokeSnapshotAccessResult: AWSDecodableShape {
        public let snapshot: Snapshot?

        @inlinable
        public init(snapshot: Snapshot? = nil) {
            self.snapshot = snapshot
        }

        private enum CodingKeys: String, CodingKey {
            case snapshot = "Snapshot"
        }
    }

    public struct RotateEncryptionKeyMessage: AWSEncodableShape {
        /// The unique identifier of the cluster that you want to rotate the encryption keys for. Constraints: Must be the name of valid cluster that has encryption enabled.
        public let clusterIdentifier: String?

        @inlinable
        public init(clusterIdentifier: String? = nil) {
            self.clusterIdentifier = clusterIdentifier
        }

        public func validate(name: String) throws {
            try self.validate(self.clusterIdentifier, name: "clusterIdentifier", parent: name, max: 2147483647)
        }

        private enum CodingKeys: String, CodingKey {
            case clusterIdentifier = "ClusterIdentifier"
        }
    }

    public struct RotateEncryptionKeyResult: AWSDecodableShape {
        public let cluster: Cluster?

        @inlinable
        public init(cluster: Cluster? = nil) {
            self.cluster = cluster
        }

        private enum CodingKeys: String, CodingKey {
            case cluster = "Cluster"
        }
    }

    public struct ScheduledAction: AWSDecodableShape {
        public struct _NextInvocationsEncoding: ArrayCoderProperties { public static let member = "ScheduledActionTime" }

        /// The end time in UTC when the schedule is no longer active. After this time, the scheduled action does not trigger.
        public let endTime: Date?
        /// The IAM role to assume to run the scheduled action.  This IAM role must have permission to run the Amazon Redshift API operation in the scheduled action. This IAM role must allow the Amazon Redshift scheduler (Principal scheduler.redshift.amazonaws.com) to assume permissions on your behalf.
        /// For more information about the IAM role to use with the Amazon Redshift scheduler, see
        /// Using Identity-Based Policies for Amazon Redshift
        /// in the Amazon Redshift Cluster Management Guide.
        public let iamRole: String?
        /// List of times when the scheduled action will run.
        @OptionalCustomCoding<ArrayCoder<_NextInvocationsEncoding, Date>>
        public var nextInvocations: [Date]?
        /// The schedule for a one-time (at format) or recurring (cron format) scheduled action.  Schedule invocations must be separated by at least one hour. Format of at expressions is "at(yyyy-mm-ddThh:mm:ss)". For example, "at(2016-03-04T17:27:00)". Format of cron expressions is "cron(Minutes Hours Day-of-month Month Day-of-week Year)".  For example, "cron(0 10 ? * MON *)". For more information, see  Cron Expressions  in the Amazon CloudWatch Events User Guide.
        public let schedule: String?
        /// The description of the scheduled action.
        public let scheduledActionDescription: String?
        /// The name of the scheduled action.
        public let scheduledActionName: String?
        /// The start time in UTC when the schedule is active. Before this time, the scheduled action does not trigger.
        public let startTime: Date?
        /// The state of the scheduled action. For example, DISABLED.
        public let state: ScheduledActionState?
        /// A JSON format string of the Amazon Redshift API operation with input parameters.  "{\"ResizeCluster\":{\"NodeType\":\"ra3.4xlarge\",\"ClusterIdentifier\":\"my-test-cluster\",\"NumberOfNodes\":3}}".
        public let targetAction: ScheduledActionType?

        @inlinable
        public init(endTime: Date? = nil, iamRole: String? = nil, nextInvocations: [Date]? = nil, schedule: String? = nil, scheduledActionDescription: String? = nil, scheduledActionName: String? = nil, startTime: Date? = nil, state: ScheduledActionState? = nil, targetAction: ScheduledActionType? = nil) {
            self.endTime = endTime
            self.iamRole = iamRole
            self.nextInvocations = nextInvocations
            self.schedule = schedule
            self.scheduledActionDescription = scheduledActionDescription
            self.scheduledActionName = scheduledActionName
            self.startTime = startTime
            self.state = state
            self.targetAction = targetAction
        }

        private enum CodingKeys: String, CodingKey {
            case endTime = "EndTime"
            case iamRole = "IamRole"
            case nextInvocations = "NextInvocations"
            case schedule = "Schedule"
            case scheduledActionDescription = "ScheduledActionDescription"
            case scheduledActionName = "ScheduledActionName"
            case startTime = "StartTime"
            case state = "State"
            case targetAction = "TargetAction"
        }
    }

    public struct ScheduledActionFilter: AWSEncodableShape {
        public struct _ValuesEncoding: ArrayCoderProperties { public static let member = "item" }

        /// The type of element to filter.
        public let name: ScheduledActionFilterName?
        /// List of values. Compare if the value (of type defined by Name) equals an item in the list of scheduled actions.
        @OptionalCustomCoding<ArrayCoder<_ValuesEncoding, String>>
        public var values: [String]?

        @inlinable
        public init(name: ScheduledActionFilterName? = nil, values: [String]? = nil) {
            self.name = name
            self.values = values
        }

        public func validate(name: String) throws {
            try self.values?.forEach {
                try validate($0, name: "values[]", parent: name, max: 2147483647)
            }
        }

        private enum CodingKeys: String, CodingKey {
            case name = "Name"
            case values = "Values"
        }
    }

    public struct ScheduledActionType: AWSEncodableShape & AWSDecodableShape {
        /// An action that runs a PauseCluster API operation.
        public let pauseCluster: PauseClusterMessage?
        /// An action that runs a ResizeCluster API operation.
        public let resizeCluster: ResizeClusterMessage?
        /// An action that runs a ResumeCluster API operation.
        public let resumeCluster: ResumeClusterMessage?

        @inlinable
        public init(pauseCluster: PauseClusterMessage? = nil, resizeCluster: ResizeClusterMessage? = nil, resumeCluster: ResumeClusterMessage? = nil) {
            self.pauseCluster = pauseCluster
            self.resizeCluster = resizeCluster
            self.resumeCluster = resumeCluster
        }

        public func validate(name: String) throws {
            try self.pauseCluster?.validate(name: "\(name).pauseCluster")
            try self.resizeCluster?.validate(name: "\(name).resizeCluster")
            try self.resumeCluster?.validate(name: "\(name).resumeCluster")
        }

        private enum CodingKeys: String, CodingKey {
            case pauseCluster = "PauseCluster"
            case resizeCluster = "ResizeCluster"
            case resumeCluster = "ResumeCluster"
        }
    }

    public struct ScheduledActionsMessage: AWSDecodableShape {
        public struct _ScheduledActionsEncoding: ArrayCoderProperties { public static let member = "ScheduledAction" }

        /// An optional parameter that specifies the starting point to return a set of response records. When the results of a DescribeScheduledActions request exceed the value specified in MaxRecords, Amazon Web Services returns a value in the Marker field of the response. You can retrieve the next set of response records by providing the returned marker value in the Marker parameter and retrying the request.
        public let marker: String?
        /// List of retrieved scheduled actions.
        @OptionalCustomCoding<ArrayCoder<_ScheduledActionsEncoding, ScheduledAction>>
        public var scheduledActions: [ScheduledAction]?

        @inlinable
        public init(marker: String? = nil, scheduledActions: [ScheduledAction]? = nil) {
            self.marker = marker
            self.scheduledActions = scheduledActions
        }

        private enum CodingKeys: String, CodingKey {
            case marker = "Marker"
            case scheduledActions = "ScheduledActions"
        }
    }

    public struct SecondaryClusterInfo: AWSDecodableShape {
        /// The name of the Availability Zone in which the secondary compute unit of the cluster is located.
        public let availabilityZone: String?
        /// The nodes in the secondary compute unit.
        @OptionalCustomCoding<StandardArrayCoder<ClusterNode>>
        public var clusterNodes: [ClusterNode]?

        @inlinable
        public init(availabilityZone: String? = nil, clusterNodes: [ClusterNode]? = nil) {
            self.availabilityZone = availabilityZone
            self.clusterNodes = clusterNodes
        }

        private enum CodingKeys: String, CodingKey {
            case availabilityZone = "AvailabilityZone"
            case clusterNodes = "ClusterNodes"
        }
    }

    public struct ServerlessIdentifier: AWSEncodableShape {
        /// The unique identifier for the serverless namespace.
        public let namespaceIdentifier: String?
        /// The unique identifier for the workgroup  associated with the serverless namespace.
        public let workgroupIdentifier: String?

        @inlinable
        public init(namespaceIdentifier: String? = nil, workgroupIdentifier: String? = nil) {
            self.namespaceIdentifier = namespaceIdentifier
            self.workgroupIdentifier = workgroupIdentifier
        }

        public func validate(name: String) throws {
            try self.validate(self.namespaceIdentifier, name: "namespaceIdentifier", parent: name, max: 2147483647)
            try self.validate(self.workgroupIdentifier, name: "workgroupIdentifier", parent: name, max: 2147483647)
        }

        private enum CodingKeys: String, CodingKey {
            case namespaceIdentifier = "NamespaceIdentifier"
            case workgroupIdentifier = "WorkgroupIdentifier"
        }
    }

    public struct Snapshot: AWSDecodableShape {
        public struct _AccountsWithRestoreAccessEncoding: ArrayCoderProperties { public static let member = "AccountWithRestoreAccess" }
        public struct _RestorableNodeTypesEncoding: ArrayCoderProperties { public static let member = "NodeType" }
        public struct _TagsEncoding: ArrayCoderProperties { public static let member = "Tag" }

        /// A list of the Amazon Web Services accounts authorized to restore the snapshot. Returns null if no accounts are authorized. Visible only to the snapshot owner.
        @OptionalCustomCoding<ArrayCoder<_AccountsWithRestoreAccessEncoding, AccountWithRestoreAccess>>
        public var accountsWithRestoreAccess: [AccountWithRestoreAccess]?
        /// The size of the incremental backup.
        public let actualIncrementalBackupSizeInMegaBytes: Double?
        /// The Availability Zone in which the cluster was created.
        public let availabilityZone: String?
        /// The number of megabytes that have been transferred to the snapshot backup.
        public let backupProgressInMegaBytes: Double?
        /// The time (UTC) when the cluster was originally created.
        public let clusterCreateTime: Date?
        /// The identifier of the cluster for which the snapshot was taken.
        public let clusterIdentifier: String?
        /// The version ID of the Amazon Redshift engine that is running on the cluster.
        public let clusterVersion: String?
        /// The number of megabytes per second being transferred to the snapshot backup. Returns 0 for a completed backup.
        public let currentBackupRateInMegaBytesPerSecond: Double?
        /// The name of the database that was created when the cluster was created.
        public let dbName: String?
        /// The amount of time an in-progress snapshot backup has been running, or the amount of time it took a completed backup to finish.
        public let elapsedTimeInSeconds: Int64?
        /// If true, the data in the snapshot is encrypted at rest.
        public let encrypted: Bool?
        /// A boolean that indicates whether the snapshot data is encrypted using the HSM keys of the source cluster. true indicates that the data is encrypted using HSM keys.
        public let encryptedWithHSM: Bool?
        /// The cluster version of the cluster used to create the snapshot. For example, 1.0.15503.
        public let engineFullVersion: String?
        /// An option that specifies whether to create the cluster with enhanced VPC routing enabled. To create a cluster that uses enhanced VPC routing, the cluster must be in a VPC. For more information, see Enhanced VPC Routing in the Amazon Redshift Cluster Management Guide. If this option is true, enhanced VPC routing is enabled.  Default: false
        public let enhancedVpcRouting: Bool?
        /// The estimate of the time remaining before the snapshot backup will complete. Returns 0 for a completed backup.
        public let estimatedSecondsToCompletion: Int64?
        /// The Key Management Service (KMS) key ID of the encryption key that was used to encrypt data in the cluster from which the snapshot was taken.
        public let kmsKeyId: String?
        /// The name of the maintenance track for the snapshot.
        public let maintenanceTrackName: String?
        /// The number of days until a manual snapshot will pass its retention period.
        public let manualSnapshotRemainingDays: Int?
        /// The number of days that a manual snapshot is retained. If the value is -1, the manual snapshot is retained indefinitely.  The value must be either -1 or an integer between 1 and 3,653.
        public let manualSnapshotRetentionPeriod: Int?
        /// The Amazon Resource Name (ARN) for the cluster's admin user credentials secret.
        public let masterPasswordSecretArn: String?
        /// The ID of the Key Management Service (KMS) key used to encrypt and store the cluster's admin credentials secret.
        public let masterPasswordSecretKmsKeyId: String?
        /// The admin user name for the cluster.
        public let masterUsername: String?
        /// The node type of the nodes in the cluster.
        public let nodeType: String?
        /// The number of nodes in the cluster.
        public let numberOfNodes: Int?
        /// For manual snapshots, the Amazon Web Services account used to create or copy the snapshot. For automatic snapshots, the owner of the cluster. The owner can perform all snapshot actions, such as sharing a manual snapshot.
        public let ownerAccount: String?
        /// The port that the cluster is listening on.
        public let port: Int?
        /// The list of node types that this cluster snapshot is able to restore into.
        @OptionalCustomCoding<ArrayCoder<_RestorableNodeTypesEncoding, String>>
        public var restorableNodeTypes: [String]?
        /// The Amazon Resource Name (ARN) of the snapshot.
        public let snapshotArn: String?
        /// The time (in UTC format) when Amazon Redshift began the snapshot. A snapshot contains a copy of the cluster data as of this exact time.
        public let snapshotCreateTime: Date?
        /// The snapshot identifier that is provided in the request.
        public let snapshotIdentifier: String?
        /// A timestamp representing the start of the retention period for the snapshot.
        public let snapshotRetentionStartTime: Date?
        /// The snapshot type. Snapshots created using CreateClusterSnapshot and CopyClusterSnapshot are of type "manual".
        public let snapshotType: String?
        /// The source region from which the snapshot was copied.
        public let sourceRegion: String?
        /// The snapshot status. The value of the status depends on the API operation used:     CreateClusterSnapshot and CopyClusterSnapshot returns status as "creating".     DescribeClusterSnapshots returns status as "creating", "available", "final snapshot", or "failed".    DeleteClusterSnapshot returns status as "deleted".
        public let status: String?
        /// The list of tags for the cluster snapshot.
        @OptionalCustomCoding<ArrayCoder<_TagsEncoding, Tag>>
        public var tags: [Tag]?
        /// The size of the complete set of backup data that would be used to restore the cluster.
        public let totalBackupSizeInMegaBytes: Double?
        /// The VPC identifier of the cluster if the snapshot is from a cluster in a VPC. Otherwise, this field is not in the output.
        public let vpcId: String?

        @inlinable
        public init(accountsWithRestoreAccess: [AccountWithRestoreAccess]? = nil, actualIncrementalBackupSizeInMegaBytes: Double? = nil, availabilityZone: String? = nil, backupProgressInMegaBytes: Double? = nil, clusterCreateTime: Date? = nil, clusterIdentifier: String? = nil, clusterVersion: String? = nil, currentBackupRateInMegaBytesPerSecond: Double? = nil, dbName: String? = nil, elapsedTimeInSeconds: Int64? = nil, encrypted: Bool? = nil, encryptedWithHSM: Bool? = nil, engineFullVersion: String? = nil, enhancedVpcRouting: Bool? = nil, estimatedSecondsToCompletion: Int64? = nil, kmsKeyId: String? = nil, maintenanceTrackName: String? = nil, manualSnapshotRemainingDays: Int? = nil, manualSnapshotRetentionPeriod: Int? = nil, masterPasswordSecretArn: String? = nil, masterPasswordSecretKmsKeyId: String? = nil, masterUsername: String? = nil, nodeType: String? = nil, numberOfNodes: Int? = nil, ownerAccount: String? = nil, port: Int? = nil, restorableNodeTypes: [String]? = nil, snapshotArn: String? = nil, snapshotCreateTime: Date? = nil, snapshotIdentifier: String? = nil, snapshotRetentionStartTime: Date? = nil, snapshotType: String? = nil, sourceRegion: String? = nil, status: String? = nil, tags: [Tag]? = nil, totalBackupSizeInMegaBytes: Double? = nil, vpcId: String? = nil) {
            self.accountsWithRestoreAccess = accountsWithRestoreAccess
            self.actualIncrementalBackupSizeInMegaBytes = actualIncrementalBackupSizeInMegaBytes
            self.availabilityZone = availabilityZone
            self.backupProgressInMegaBytes = backupProgressInMegaBytes
            self.clusterCreateTime = clusterCreateTime
            self.clusterIdentifier = clusterIdentifier
            self.clusterVersion = clusterVersion
            self.currentBackupRateInMegaBytesPerSecond = currentBackupRateInMegaBytesPerSecond
            self.dbName = dbName
            self.elapsedTimeInSeconds = elapsedTimeInSeconds
            self.encrypted = encrypted
            self.encryptedWithHSM = encryptedWithHSM
            self.engineFullVersion = engineFullVersion
            self.enhancedVpcRouting = enhancedVpcRouting
            self.estimatedSecondsToCompletion = estimatedSecondsToCompletion
            self.kmsKeyId = kmsKeyId
            self.maintenanceTrackName = maintenanceTrackName
            self.manualSnapshotRemainingDays = manualSnapshotRemainingDays
            self.manualSnapshotRetentionPeriod = manualSnapshotRetentionPeriod
            self.masterPasswordSecretArn = masterPasswordSecretArn
            self.masterPasswordSecretKmsKeyId = masterPasswordSecretKmsKeyId
            self.masterUsername = masterUsername
            self.nodeType = nodeType
            self.numberOfNodes = numberOfNodes
            self.ownerAccount = ownerAccount
            self.port = port
            self.restorableNodeTypes = restorableNodeTypes
            self.snapshotArn = snapshotArn
            self.snapshotCreateTime = snapshotCreateTime
            self.snapshotIdentifier = snapshotIdentifier
            self.snapshotRetentionStartTime = snapshotRetentionStartTime
            self.snapshotType = snapshotType
            self.sourceRegion = sourceRegion
            self.status = status
            self.tags = tags
            self.totalBackupSizeInMegaBytes = totalBackupSizeInMegaBytes
            self.vpcId = vpcId
        }

        private enum CodingKeys: String, CodingKey {
            case accountsWithRestoreAccess = "AccountsWithRestoreAccess"
            case actualIncrementalBackupSizeInMegaBytes = "ActualIncrementalBackupSizeInMegaBytes"
            case availabilityZone = "AvailabilityZone"
            case backupProgressInMegaBytes = "BackupProgressInMegaBytes"
            case clusterCreateTime = "ClusterCreateTime"
            case clusterIdentifier = "ClusterIdentifier"
            case clusterVersion = "ClusterVersion"
            case currentBackupRateInMegaBytesPerSecond = "CurrentBackupRateInMegaBytesPerSecond"
            case dbName = "DBName"
            case elapsedTimeInSeconds = "ElapsedTimeInSeconds"
            case encrypted = "Encrypted"
            case encryptedWithHSM = "EncryptedWithHSM"
            case engineFullVersion = "EngineFullVersion"
            case enhancedVpcRouting = "EnhancedVpcRouting"
            case estimatedSecondsToCompletion = "EstimatedSecondsToCompletion"
            case kmsKeyId = "KmsKeyId"
            case maintenanceTrackName = "MaintenanceTrackName"
            case manualSnapshotRemainingDays = "ManualSnapshotRemainingDays"
            case manualSnapshotRetentionPeriod = "ManualSnapshotRetentionPeriod"
            case masterPasswordSecretArn = "MasterPasswordSecretArn"
            case masterPasswordSecretKmsKeyId = "MasterPasswordSecretKmsKeyId"
            case masterUsername = "MasterUsername"
            case nodeType = "NodeType"
            case numberOfNodes = "NumberOfNodes"
            case ownerAccount = "OwnerAccount"
            case port = "Port"
            case restorableNodeTypes = "RestorableNodeTypes"
            case snapshotArn = "SnapshotArn"
            case snapshotCreateTime = "SnapshotCreateTime"
            case snapshotIdentifier = "SnapshotIdentifier"
            case snapshotRetentionStartTime = "SnapshotRetentionStartTime"
            case snapshotType = "SnapshotType"
            case sourceRegion = "SourceRegion"
            case status = "Status"
            case tags = "Tags"
            case totalBackupSizeInMegaBytes = "TotalBackupSizeInMegaBytes"
            case vpcId = "VpcId"
        }
    }

    public struct SnapshotCopyGrant: AWSDecodableShape {
        public struct _TagsEncoding: ArrayCoderProperties { public static let member = "Tag" }

        /// The unique identifier of the encrypted symmetric key in Amazon Web Services KMS to which Amazon Redshift is granted permission.
        public let kmsKeyId: String?
        /// The name of the snapshot copy grant.
        public let snapshotCopyGrantName: String?
        /// A list of tag instances.
        @OptionalCustomCoding<ArrayCoder<_TagsEncoding, Tag>>
        public var tags: [Tag]?

        @inlinable
        public init(kmsKeyId: String? = nil, snapshotCopyGrantName: String? = nil, tags: [Tag]? = nil) {
            self.kmsKeyId = kmsKeyId
            self.snapshotCopyGrantName = snapshotCopyGrantName
            self.tags = tags
        }

        private enum CodingKeys: String, CodingKey {
            case kmsKeyId = "KmsKeyId"
            case snapshotCopyGrantName = "SnapshotCopyGrantName"
            case tags = "Tags"
        }
    }

    public struct SnapshotCopyGrantMessage: AWSDecodableShape {
        public struct _SnapshotCopyGrantsEncoding: ArrayCoderProperties { public static let member = "SnapshotCopyGrant" }

        /// An optional parameter that specifies the starting point to return a set of response records. When the results of a DescribeSnapshotCopyGrant request exceed the value specified in MaxRecords, Amazon Web Services returns a value in the Marker field of the response. You can retrieve the next set of response records by providing the returned marker value in the Marker parameter and retrying the request.  Constraints: You can specify either the SnapshotCopyGrantName parameter or the Marker parameter, but not both.
        public let marker: String?
        /// The list of SnapshotCopyGrant objects.
        @OptionalCustomCoding<ArrayCoder<_SnapshotCopyGrantsEncoding, SnapshotCopyGrant>>
        public var snapshotCopyGrants: [SnapshotCopyGrant]?

        @inlinable
        public init(marker: String? = nil, snapshotCopyGrants: [SnapshotCopyGrant]? = nil) {
            self.marker = marker
            self.snapshotCopyGrants = snapshotCopyGrants
        }

        private enum CodingKeys: String, CodingKey {
            case marker = "Marker"
            case snapshotCopyGrants = "SnapshotCopyGrants"
        }
    }

    public struct SnapshotErrorMessage: AWSDecodableShape {
        /// The failure code for the error.
        public let failureCode: String?
        /// The text message describing the error.
        public let failureReason: String?
        /// A unique identifier for the cluster.
        public let snapshotClusterIdentifier: String?
        /// A unique identifier for the snapshot returning the error.
        public let snapshotIdentifier: String?

        @inlinable
        public init(failureCode: String? = nil, failureReason: String? = nil, snapshotClusterIdentifier: String? = nil, snapshotIdentifier: String? = nil) {
            self.failureCode = failureCode
            self.failureReason = failureReason
            self.snapshotClusterIdentifier = snapshotClusterIdentifier
            self.snapshotIdentifier = snapshotIdentifier
        }

        private enum CodingKeys: String, CodingKey {
            case failureCode = "FailureCode"
            case failureReason = "FailureReason"
            case snapshotClusterIdentifier = "SnapshotClusterIdentifier"
            case snapshotIdentifier = "SnapshotIdentifier"
        }
    }

    public struct SnapshotMessage: AWSDecodableShape {
        public struct _SnapshotsEncoding: ArrayCoderProperties { public static let member = "Snapshot" }

        /// A value that indicates the starting point for the next set of response records in a subsequent request. If a value is returned in a response, you can retrieve the next set of records by providing this returned marker value in the Marker parameter and retrying the command. If the Marker field is empty, all response records have been retrieved for the request.
        public let marker: String?
        /// A list of Snapshot instances.
        @OptionalCustomCoding<ArrayCoder<_SnapshotsEncoding, Snapshot>>
        public var snapshots: [Snapshot]?

        @inlinable
        public init(marker: String? = nil, snapshots: [Snapshot]? = nil) {
            self.marker = marker
            self.snapshots = snapshots
        }

        private enum CodingKeys: String, CodingKey {
            case marker = "Marker"
            case snapshots = "Snapshots"
        }
    }

    public struct SnapshotSchedule: AWSDecodableShape {
        public struct _AssociatedClustersEncoding: ArrayCoderProperties { public static let member = "ClusterAssociatedToSchedule" }
        public struct _NextInvocationsEncoding: ArrayCoderProperties { public static let member = "SnapshotTime" }
        public struct _ScheduleDefinitionsEncoding: ArrayCoderProperties { public static let member = "ScheduleDefinition" }
        public struct _TagsEncoding: ArrayCoderProperties { public static let member = "Tag" }

        /// The number of clusters associated with the schedule.
        public let associatedClusterCount: Int?
        /// A list of clusters associated with the schedule. A maximum of 100 clusters is returned.
        @OptionalCustomCoding<ArrayCoder<_AssociatedClustersEncoding, ClusterAssociatedToSchedule>>
        public var associatedClusters: [ClusterAssociatedToSchedule]?
        @OptionalCustomCoding<ArrayCoder<_NextInvocationsEncoding, Date>>
        public var nextInvocations: [Date]?
        /// A list of ScheduleDefinitions.
        @OptionalCustomCoding<ArrayCoder<_ScheduleDefinitionsEncoding, String>>
        public var scheduleDefinitions: [String]?
        /// The description of the schedule.
        public let scheduleDescription: String?
        /// A unique identifier for the schedule.
        public let scheduleIdentifier: String?
        /// An optional set of tags describing the schedule.
        @OptionalCustomCoding<ArrayCoder<_TagsEncoding, Tag>>
        public var tags: [Tag]?

        @inlinable
        public init(associatedClusterCount: Int? = nil, associatedClusters: [ClusterAssociatedToSchedule]? = nil, nextInvocations: [Date]? = nil, scheduleDefinitions: [String]? = nil, scheduleDescription: String? = nil, scheduleIdentifier: String? = nil, tags: [Tag]? = nil) {
            self.associatedClusterCount = associatedClusterCount
            self.associatedClusters = associatedClusters
            self.nextInvocations = nextInvocations
            self.scheduleDefinitions = scheduleDefinitions
            self.scheduleDescription = scheduleDescription
            self.scheduleIdentifier = scheduleIdentifier
            self.tags = tags
        }

        private enum CodingKeys: String, CodingKey {
            case associatedClusterCount = "AssociatedClusterCount"
            case associatedClusters = "AssociatedClusters"
            case nextInvocations = "NextInvocations"
            case scheduleDefinitions = "ScheduleDefinitions"
            case scheduleDescription = "ScheduleDescription"
            case scheduleIdentifier = "ScheduleIdentifier"
            case tags = "Tags"
        }
    }

    public struct SnapshotSortingEntity: AWSEncodableShape {
        /// The category for sorting the snapshots.
        public let attribute: SnapshotAttributeToSortBy?
        /// The order for listing the attributes.
        public let sortOrder: SortByOrder?

        @inlinable
        public init(attribute: SnapshotAttributeToSortBy? = nil, sortOrder: SortByOrder? = nil) {
            self.attribute = attribute
            self.sortOrder = sortOrder
        }

        private enum CodingKeys: String, CodingKey {
            case attribute = "Attribute"
            case sortOrder = "SortOrder"
        }
    }

    public struct Subnet: AWSDecodableShape {
        public let subnetAvailabilityZone: AvailabilityZone?
        /// The identifier of the subnet.
        public let subnetIdentifier: String?
        /// The status of the subnet.
        public let subnetStatus: String?

        @inlinable
        public init(subnetAvailabilityZone: AvailabilityZone? = nil, subnetIdentifier: String? = nil, subnetStatus: String? = nil) {
            self.subnetAvailabilityZone = subnetAvailabilityZone
            self.subnetIdentifier = subnetIdentifier
            self.subnetStatus = subnetStatus
        }

        private enum CodingKeys: String, CodingKey {
            case subnetAvailabilityZone = "SubnetAvailabilityZone"
            case subnetIdentifier = "SubnetIdentifier"
            case subnetStatus = "SubnetStatus"
        }
    }

    public struct SupportedOperation: AWSDecodableShape {
        /// A list of the supported operations.
        public let operationName: String?

        @inlinable
        public init(operationName: String? = nil) {
            self.operationName = operationName
        }

        private enum CodingKeys: String, CodingKey {
            case operationName = "OperationName"
        }
    }

    public struct SupportedPlatform: AWSDecodableShape {
        public let name: String?

        @inlinable
        public init(name: String? = nil) {
            self.name = name
        }

        private enum CodingKeys: String, CodingKey {
            case name = "Name"
        }
    }

    public struct TableRestoreStatus: AWSDecodableShape {
        /// The identifier of the Amazon Redshift cluster that the table is being restored to.
        public let clusterIdentifier: String?
        /// A description of the status of the table restore request. Status values include SUCCEEDED, FAILED, CANCELED, PENDING, IN_PROGRESS.
        public let message: String?
        /// The name of the table to create as a result of the table restore request.
        public let newTableName: String?
        /// The amount of data restored to the new table so far, in megabytes (MB).
        public let progressInMegaBytes: Int64?
        /// The time that the table restore request was made, in Universal Coordinated Time (UTC).
        public let requestTime: Date?
        /// The identifier of the snapshot that the table is being restored from.
        public let snapshotIdentifier: String?
        /// The name of the source database that contains the table being restored.
        public let sourceDatabaseName: String?
        /// The name of the source schema that contains the table being restored.
        public let sourceSchemaName: String?
        /// The name of the source table being restored.
        public let sourceTableName: String?
        /// A value that describes the current state of the table restore request. Valid Values: SUCCEEDED, FAILED, CANCELED, PENDING, IN_PROGRESS
        public let status: TableRestoreStatusType?
        /// The unique identifier for the table restore request.
        public let tableRestoreRequestId: String?
        /// The name of the database to restore the table to.
        public let targetDatabaseName: String?
        /// The name of the schema to restore the table to.
        public let targetSchemaName: String?
        /// The total amount of data to restore to the new table, in megabytes (MB).
        public let totalDataInMegaBytes: Int64?

        @inlinable
        public init(clusterIdentifier: String? = nil, message: String? = nil, newTableName: String? = nil, progressInMegaBytes: Int64? = nil, requestTime: Date? = nil, snapshotIdentifier: String? = nil, sourceDatabaseName: String? = nil, sourceSchemaName: String? = nil, sourceTableName: String? = nil, status: TableRestoreStatusType? = nil, tableRestoreRequestId: String? = nil, targetDatabaseName: String? = nil, targetSchemaName: String? = nil, totalDataInMegaBytes: Int64? = nil) {
            self.clusterIdentifier = clusterIdentifier
            self.message = message
            self.newTableName = newTableName
            self.progressInMegaBytes = progressInMegaBytes
            self.requestTime = requestTime
            self.snapshotIdentifier = snapshotIdentifier
            self.sourceDatabaseName = sourceDatabaseName
            self.sourceSchemaName = sourceSchemaName
            self.sourceTableName = sourceTableName
            self.status = status
            self.tableRestoreRequestId = tableRestoreRequestId
            self.targetDatabaseName = targetDatabaseName
            self.targetSchemaName = targetSchemaName
            self.totalDataInMegaBytes = totalDataInMegaBytes
        }

        private enum CodingKeys: String, CodingKey {
            case clusterIdentifier = "ClusterIdentifier"
            case message = "Message"
            case newTableName = "NewTableName"
            case progressInMegaBytes = "ProgressInMegaBytes"
            case requestTime = "RequestTime"
            case snapshotIdentifier = "SnapshotIdentifier"
            case sourceDatabaseName = "SourceDatabaseName"
            case sourceSchemaName = "SourceSchemaName"
            case sourceTableName = "SourceTableName"
            case status = "Status"
            case tableRestoreRequestId = "TableRestoreRequestId"
            case targetDatabaseName = "TargetDatabaseName"
            case targetSchemaName = "TargetSchemaName"
            case totalDataInMegaBytes = "TotalDataInMegaBytes"
        }
    }

    public struct TableRestoreStatusMessage: AWSDecodableShape {
        public struct _TableRestoreStatusDetailsEncoding: ArrayCoderProperties { public static let member = "TableRestoreStatus" }

        /// A pagination token that can be used in a subsequent DescribeTableRestoreStatus request.
        public let marker: String?
        /// A list of status details for one or more table restore requests.
        @OptionalCustomCoding<ArrayCoder<_TableRestoreStatusDetailsEncoding, TableRestoreStatus>>
        public var tableRestoreStatusDetails: [TableRestoreStatus]?

        @inlinable
        public init(marker: String? = nil, tableRestoreStatusDetails: [TableRestoreStatus]? = nil) {
            self.marker = marker
            self.tableRestoreStatusDetails = tableRestoreStatusDetails
        }

        private enum CodingKeys: String, CodingKey {
            case marker = "Marker"
            case tableRestoreStatusDetails = "TableRestoreStatusDetails"
        }
    }

    public struct Tag: AWSEncodableShape & AWSDecodableShape {
        /// The key, or name, for the resource tag.
        public let key: String?
        /// The value for the resource tag.
        public let value: String?

        @inlinable
        public init(key: String? = nil, value: String? = nil) {
            self.key = key
            self.value = value
        }

        public func validate(name: String) throws {
            try self.validate(self.key, name: "key", parent: name, max: 2147483647)
            try self.validate(self.value, name: "value", parent: name, max: 2147483647)
        }

        private enum CodingKeys: String, CodingKey {
            case key = "Key"
            case value = "Value"
        }
    }

    public struct TaggedResource: AWSDecodableShape {
        /// The Amazon Resource Name (ARN) with which the tag is associated, for example: arn:aws:redshift:us-east-2:123456789:cluster:t1.
        public let resourceName: String?
        /// The type of resource with which the tag is associated. Valid resource types are:    Cluster   CIDR/IP   EC2 security group   Snapshot   Cluster security group   Subnet group   HSM connection   HSM certificate   Parameter group   For more information about Amazon Redshift resource types and constructing ARNs, go to Constructing an Amazon Redshift Amazon Resource Name (ARN) in the Amazon Redshift Cluster Management Guide.
        public let resourceType: String?
        /// The tag for the resource.
        public let tag: Tag?

        @inlinable
        public init(resourceName: String? = nil, resourceType: String? = nil, tag: Tag? = nil) {
            self.resourceName = resourceName
            self.resourceType = resourceType
            self.tag = tag
        }

        private enum CodingKeys: String, CodingKey {
            case resourceName = "ResourceName"
            case resourceType = "ResourceType"
            case tag = "Tag"
        }
    }

    public struct TaggedResourceListMessage: AWSDecodableShape {
        public struct _TaggedResourcesEncoding: ArrayCoderProperties { public static let member = "TaggedResource" }

        /// A value that indicates the starting point for the next set of response records in a subsequent request. If a value is returned in a response, you can retrieve the next set of records by providing this returned marker value in the Marker parameter and retrying the command. If the Marker field is empty, all response records have been retrieved for the request.
        public let marker: String?
        /// A list of tags with their associated resources.
        @OptionalCustomCoding<ArrayCoder<_TaggedResourcesEncoding, TaggedResource>>
        public var taggedResources: [TaggedResource]?

        @inlinable
        public init(marker: String? = nil, taggedResources: [TaggedResource]? = nil) {
            self.marker = marker
            self.taggedResources = taggedResources
        }

        private enum CodingKeys: String, CodingKey {
            case marker = "Marker"
            case taggedResources = "TaggedResources"
        }
    }

    public struct TrackListMessage: AWSDecodableShape {
        public struct _MaintenanceTracksEncoding: ArrayCoderProperties { public static let member = "MaintenanceTrack" }

        /// A list of maintenance tracks output by the DescribeClusterTracks operation.
        @OptionalCustomCoding<ArrayCoder<_MaintenanceTracksEncoding, MaintenanceTrack>>
        public var maintenanceTracks: [MaintenanceTrack]?
        /// The starting point to return a set of response tracklist records. You can retrieve the next set of response records by providing the returned marker value in the Marker parameter and retrying the request.
        public let marker: String?

        @inlinable
        public init(maintenanceTracks: [MaintenanceTrack]? = nil, marker: String? = nil) {
            self.maintenanceTracks = maintenanceTracks
            self.marker = marker
        }

        private enum CodingKeys: String, CodingKey {
            case maintenanceTracks = "MaintenanceTracks"
            case marker = "Marker"
        }
    }

    public struct UpdatePartnerStatusInputMessage: AWSEncodableShape {
        /// The Amazon Web Services account ID that owns the cluster.
        public let accountId: String?
        /// The cluster identifier of the cluster whose partner integration status is being updated.
        public let clusterIdentifier: String?
        /// The name of the database whose partner integration status is being updated.
        public let databaseName: String?
        /// The name of the partner whose integration status is being updated.
        public let partnerName: String?
        /// The value of the updated status.
        public let status: PartnerIntegrationStatus?
        /// The status message provided by the partner.
        public let statusMessage: String?

        @inlinable
        public init(accountId: String? = nil, clusterIdentifier: String? = nil, databaseName: String? = nil, partnerName: String? = nil, status: PartnerIntegrationStatus? = nil, statusMessage: String? = nil) {
            self.accountId = accountId
            self.clusterIdentifier = clusterIdentifier
            self.databaseName = databaseName
            self.partnerName = partnerName
            self.status = status
            self.statusMessage = statusMessage
        }

        public func validate(name: String) throws {
            try self.validate(self.accountId, name: "accountId", parent: name, max: 12)
            try self.validate(self.accountId, name: "accountId", parent: name, min: 12)
            try self.validate(self.accountId, name: "accountId", parent: name, pattern: "^[0-9]+$")
            try self.validate(self.clusterIdentifier, name: "clusterIdentifier", parent: name, max: 63)
            try self.validate(self.clusterIdentifier, name: "clusterIdentifier", parent: name, pattern: "^[a-zA-Z0-9\\-]+$")
            try self.validate(self.databaseName, name: "databaseName", parent: name, max: 127)
            try self.validate(self.databaseName, name: "databaseName", parent: name, pattern: "^[\\p{L}_][\\p{L}\\p{N}@$#_]+$")
            try self.validate(self.partnerName, name: "partnerName", parent: name, max: 255)
            try self.validate(self.partnerName, name: "partnerName", parent: name, pattern: "^[a-zA-Z0-9\\-_]+$")
            try self.validate(self.statusMessage, name: "statusMessage", parent: name, max: 262144)
            try self.validate(self.statusMessage, name: "statusMessage", parent: name, pattern: "^[\\x20-\\x7E]+$")
        }

        private enum CodingKeys: String, CodingKey {
            case accountId = "AccountId"
            case clusterIdentifier = "ClusterIdentifier"
            case databaseName = "DatabaseName"
            case partnerName = "PartnerName"
            case status = "Status"
            case statusMessage = "StatusMessage"
        }
    }

    public struct UpdateTarget: AWSDecodableShape {
        public struct _SupportedOperationsEncoding: ArrayCoderProperties { public static let member = "SupportedOperation" }

        /// The cluster version for the new maintenance track.
        public let databaseVersion: String?
        /// The name of the new maintenance track.
        public let maintenanceTrackName: String?
        /// A list of operations supported by the maintenance track.
        @OptionalCustomCoding<ArrayCoder<_SupportedOperationsEncoding, SupportedOperation>>
        public var supportedOperations: [SupportedOperation]?

        @inlinable
        public init(databaseVersion: String? = nil, maintenanceTrackName: String? = nil, supportedOperations: [SupportedOperation]? = nil) {
            self.databaseVersion = databaseVersion
            self.maintenanceTrackName = maintenanceTrackName
            self.supportedOperations = supportedOperations
        }

        private enum CodingKeys: String, CodingKey {
            case databaseVersion = "DatabaseVersion"
            case maintenanceTrackName = "MaintenanceTrackName"
            case supportedOperations = "SupportedOperations"
        }
    }

    public struct UsageLimit: AWSDecodableShape {
        public struct _TagsEncoding: ArrayCoderProperties { public static let member = "Tag" }

        /// The limit amount. If time-based, this amount is in minutes. If data-based, this amount is in terabytes (TB).
        public let amount: Int64?
        /// The action that Amazon Redshift takes when the limit is reached. Possible values are:     log - To log an event in a system table. The default is log.    emit-metric - To emit CloudWatch metrics.    disable - To disable the feature until the next usage period begins.
        public let breachAction: UsageLimitBreachAction?
        /// The identifier of the cluster with a usage limit.
        public let clusterIdentifier: String?
        /// The Amazon Redshift feature to which the limit applies.
        public let featureType: UsageLimitFeatureType?
        /// The type of limit. Depending on the feature type, this can be based on a time duration or data size.
        public let limitType: UsageLimitLimitType?
        /// The time period that the amount applies to. A weekly period begins on Sunday. The default is monthly.
        public let period: UsageLimitPeriod?
        /// A list of tag instances.
        @OptionalCustomCoding<ArrayCoder<_TagsEncoding, Tag>>
        public var tags: [Tag]?
        /// The identifier of the usage limit.
        public let usageLimitId: String?

        @inlinable
        public init(amount: Int64? = nil, breachAction: UsageLimitBreachAction? = nil, clusterIdentifier: String? = nil, featureType: UsageLimitFeatureType? = nil, limitType: UsageLimitLimitType? = nil, period: UsageLimitPeriod? = nil, tags: [Tag]? = nil, usageLimitId: String? = nil) {
            self.amount = amount
            self.breachAction = breachAction
            self.clusterIdentifier = clusterIdentifier
            self.featureType = featureType
            self.limitType = limitType
            self.period = period
            self.tags = tags
            self.usageLimitId = usageLimitId
        }

        private enum CodingKeys: String, CodingKey {
            case amount = "Amount"
            case breachAction = "BreachAction"
            case clusterIdentifier = "ClusterIdentifier"
            case featureType = "FeatureType"
            case limitType = "LimitType"
            case period = "Period"
            case tags = "Tags"
            case usageLimitId = "UsageLimitId"
        }
    }

    public struct UsageLimitList: AWSDecodableShape {
        /// A value that indicates the starting point for the next set of response records in a subsequent request. If a value is returned in a response, you can retrieve the next set of records by providing this returned marker value in the Marker parameter and retrying the command. If the Marker field is empty, all response records have been retrieved for the request.
        public let marker: String?
        /// Contains the output from the DescribeUsageLimits action.
        @OptionalCustomCoding<StandardArrayCoder<UsageLimit>>
        public var usageLimits: [UsageLimit]?

        @inlinable
        public init(marker: String? = nil, usageLimits: [UsageLimit]? = nil) {
            self.marker = marker
            self.usageLimits = usageLimits
        }

        private enum CodingKeys: String, CodingKey {
            case marker = "Marker"
            case usageLimits = "UsageLimits"
        }
    }

    public struct VpcEndpoint: AWSDecodableShape {
        public struct _NetworkInterfacesEncoding: ArrayCoderProperties { public static let member = "NetworkInterface" }

        /// One or more network interfaces of the endpoint. Also known as an interface endpoint.
        @OptionalCustomCoding<ArrayCoder<_NetworkInterfacesEncoding, NetworkInterface>>
        public var networkInterfaces: [NetworkInterface]?
        /// The connection endpoint ID for connecting an Amazon Redshift cluster through the proxy.
        public let vpcEndpointId: String?
        /// The VPC identifier that the endpoint is associated.
        public let vpcId: String?

        @inlinable
        public init(networkInterfaces: [NetworkInterface]? = nil, vpcEndpointId: String? = nil, vpcId: String? = nil) {
            self.networkInterfaces = networkInterfaces
            self.vpcEndpointId = vpcEndpointId
            self.vpcId = vpcId
        }

        private enum CodingKeys: String, CodingKey {
            case networkInterfaces = "NetworkInterfaces"
            case vpcEndpointId = "VpcEndpointId"
            case vpcId = "VpcId"
        }
    }

    public struct VpcSecurityGroupMembership: AWSDecodableShape {
        /// The status of the VPC security group.
        public let status: String?
        /// The identifier of the VPC security group.
        public let vpcSecurityGroupId: String?

        @inlinable
        public init(status: String? = nil, vpcSecurityGroupId: String? = nil) {
            self.status = status
            self.vpcSecurityGroupId = vpcSecurityGroupId
        }

        private enum CodingKeys: String, CodingKey {
            case status = "Status"
            case vpcSecurityGroupId = "VpcSecurityGroupId"
        }
    }

    public struct LakeFormationScopeUnion: AWSEncodableShape & AWSDecodableShape {
        /// The Lake Formation scope.
        public let lakeFormationQuery: LakeFormationQuery?

        @inlinable
        public init(lakeFormationQuery: LakeFormationQuery? = nil) {
            self.lakeFormationQuery = lakeFormationQuery
        }

        private enum CodingKeys: String, CodingKey {
            case lakeFormationQuery = "LakeFormationQuery"
        }
    }

    public struct S3AccessGrantsScopeUnion: AWSEncodableShape & AWSDecodableShape {
        /// The S3 Access Grants scope.
        public let readWriteAccess: ReadWriteAccess?

        @inlinable
        public init(readWriteAccess: ReadWriteAccess? = nil) {
            self.readWriteAccess = readWriteAccess
        }

        private enum CodingKeys: String, CodingKey {
            case readWriteAccess = "ReadWriteAccess"
        }
    }
}

// MARK: - Errors

/// Error enum for Redshift
public struct RedshiftErrorType: AWSErrorType {
    enum Code: String {
        case accessToClusterDeniedFault = "AccessToClusterDenied"
        case accessToSnapshotDeniedFault = "AccessToSnapshotDenied"
        case authenticationProfileAlreadyExistsFault = "AuthenticationProfileAlreadyExistsFault"
        case authenticationProfileNotFoundFault = "AuthenticationProfileNotFoundFault"
        case authenticationProfileQuotaExceededFault = "AuthenticationProfileQuotaExceededFault"
        case authorizationAlreadyExistsFault = "AuthorizationAlreadyExists"
        case authorizationNotFoundFault = "AuthorizationNotFound"
        case authorizationQuotaExceededFault = "AuthorizationQuotaExceeded"
        case batchDeleteRequestSizeExceededFault = "BatchDeleteRequestSizeExceeded"
        case batchModifyClusterSnapshotsLimitExceededFault = "BatchModifyClusterSnapshotsLimitExceededFault"
        case bucketNotFoundFault = "BucketNotFoundFault"
        case clusterAlreadyExistsFault = "ClusterAlreadyExists"
        case clusterNotFoundFault = "ClusterNotFound"
        case clusterOnLatestRevisionFault = "ClusterOnLatestRevision"
        case clusterParameterGroupAlreadyExistsFault = "ClusterParameterGroupAlreadyExists"
        case clusterParameterGroupNotFoundFault = "ClusterParameterGroupNotFound"
        case clusterParameterGroupQuotaExceededFault = "ClusterParameterGroupQuotaExceeded"
        case clusterQuotaExceededFault = "ClusterQuotaExceeded"
        case clusterSecurityGroupAlreadyExistsFault = "ClusterSecurityGroupAlreadyExists"
        case clusterSecurityGroupNotFoundFault = "ClusterSecurityGroupNotFound"
        case clusterSecurityGroupQuotaExceededFault = "QuotaExceeded.ClusterSecurityGroup"
        case clusterSnapshotAlreadyExistsFault = "ClusterSnapshotAlreadyExists"
        case clusterSnapshotNotFoundFault = "ClusterSnapshotNotFound"
        case clusterSnapshotQuotaExceededFault = "ClusterSnapshotQuotaExceeded"
        case clusterSubnetGroupAlreadyExistsFault = "ClusterSubnetGroupAlreadyExists"
        case clusterSubnetGroupNotFoundFault = "ClusterSubnetGroupNotFoundFault"
        case clusterSubnetGroupQuotaExceededFault = "ClusterSubnetGroupQuotaExceeded"
        case clusterSubnetQuotaExceededFault = "ClusterSubnetQuotaExceededFault"
        case conflictPolicyUpdateFault = "ConflictPolicyUpdateFault"
        case copyToRegionDisabledFault = "CopyToRegionDisabledFault"
        case customCnameAssociationFault = "CustomCnameAssociationFault"
        case customDomainAssociationNotFoundFault = "CustomDomainAssociationNotFoundFault"
        case dependentServiceAccessDeniedFault = "DependentServiceAccessDenied"
        case dependentServiceRequestThrottlingFault = "DependentServiceRequestThrottlingFault"
        case dependentServiceUnavailableFault = "DependentServiceUnavailableFault"
        case endpointAlreadyExistsFault = "EndpointAlreadyExists"
        case endpointAuthorizationAlreadyExistsFault = "EndpointAuthorizationAlreadyExists"
        case endpointAuthorizationNotFoundFault = "EndpointAuthorizationNotFound"
        case endpointAuthorizationsPerClusterLimitExceededFault = "EndpointAuthorizationsPerClusterLimitExceeded"
        case endpointNotFoundFault = "EndpointNotFound"
        case endpointsPerAuthorizationLimitExceededFault = "EndpointsPerAuthorizationLimitExceeded"
        case endpointsPerClusterLimitExceededFault = "EndpointsPerClusterLimitExceeded"
        case eventSubscriptionQuotaExceededFault = "EventSubscriptionQuotaExceeded"
        case hsmClientCertificateAlreadyExistsFault = "HsmClientCertificateAlreadyExistsFault"
        case hsmClientCertificateNotFoundFault = "HsmClientCertificateNotFoundFault"
        case hsmClientCertificateQuotaExceededFault = "HsmClientCertificateQuotaExceededFault"
        case hsmConfigurationAlreadyExistsFault = "HsmConfigurationAlreadyExistsFault"
        case hsmConfigurationNotFoundFault = "HsmConfigurationNotFoundFault"
        case hsmConfigurationQuotaExceededFault = "HsmConfigurationQuotaExceededFault"
        case inProgressTableRestoreQuotaExceededFault = "InProgressTableRestoreQuotaExceededFault"
        case incompatibleOrderableOptions = "IncompatibleOrderableOptions"
        case insufficientClusterCapacityFault = "InsufficientClusterCapacity"
        case insufficientS3BucketPolicyFault = "InsufficientS3BucketPolicyFault"
        case integrationAlreadyExistsFault = "IntegrationAlreadyExistsFault"
        case integrationConflictOperationFault = "IntegrationConflictOperationFault"
        case integrationConflictStateFault = "IntegrationConflictStateFault"
        case integrationNotFoundFault = "IntegrationNotFoundFault"
        case integrationQuotaExceededFault = "IntegrationQuotaExceededFault"
        case integrationSourceNotFoundFault = "IntegrationSourceNotFoundFault"
        case integrationTargetNotFoundFault = "IntegrationTargetNotFoundFault"
        case invalidAuthenticationProfileRequestFault = "InvalidAuthenticationProfileRequestFault"
        case invalidAuthorizationStateFault = "InvalidAuthorizationState"
        case invalidClusterParameterGroupStateFault = "InvalidClusterParameterGroupState"
        case invalidClusterSecurityGroupStateFault = "InvalidClusterSecurityGroupState"
        case invalidClusterSnapshotScheduleStateFault = "InvalidClusterSnapshotScheduleState"
        case invalidClusterSnapshotStateFault = "InvalidClusterSnapshotState"
        case invalidClusterStateFault = "InvalidClusterState"
        case invalidClusterSubnetGroupStateFault = "InvalidClusterSubnetGroupStateFault"
        case invalidClusterSubnetStateFault = "InvalidClusterSubnetStateFault"
        case invalidClusterTrackFault = "InvalidClusterTrack"
        case invalidDataShareFault = "InvalidDataShareFault"
        case invalidElasticIpFault = "InvalidElasticIpFault"
        case invalidEndpointStateFault = "InvalidEndpointState"
        case invalidHsmClientCertificateStateFault = "InvalidHsmClientCertificateStateFault"
        case invalidHsmConfigurationStateFault = "InvalidHsmConfigurationStateFault"
        case invalidNamespaceFault = "InvalidNamespaceFault"
        case invalidPolicyFault = "InvalidPolicyFault"
        case invalidReservedNodeStateFault = "InvalidReservedNodeState"
        case invalidRestoreFault = "InvalidRestore"
        case invalidRetentionPeriodFault = "InvalidRetentionPeriodFault"
        case invalidS3BucketNameFault = "InvalidS3BucketNameFault"
        case invalidS3KeyPrefixFault = "InvalidS3KeyPrefixFault"
        case invalidScheduleFault = "InvalidSchedule"
        case invalidScheduledActionFault = "InvalidScheduledAction"
        case invalidSnapshotCopyGrantStateFault = "InvalidSnapshotCopyGrantStateFault"
        case invalidSubnet = "InvalidSubnet"
        case invalidSubscriptionStateFault = "InvalidSubscriptionStateFault"
        case invalidTableRestoreArgumentFault = "InvalidTableRestoreArgument"
        case invalidTagFault = "InvalidTagFault"
        case invalidUsageLimitFault = "InvalidUsageLimit"
        case invalidVPCNetworkStateFault = "InvalidVPCNetworkStateFault"
        case ipv6CidrBlockNotFoundFault = "Ipv6CidrBlockNotFoundFault"
        case limitExceededFault = "LimitExceededFault"
        case numberOfNodesPerClusterLimitExceededFault = "NumberOfNodesPerClusterLimitExceeded"
        case numberOfNodesQuotaExceededFault = "NumberOfNodesQuotaExceeded"
        case partnerNotFoundFault = "PartnerNotFound"
        case redshiftIdcApplicationAlreadyExistsFault = "RedshiftIdcApplicationAlreadyExists"
        case redshiftIdcApplicationNotExistsFault = "RedshiftIdcApplicationNotExists"
        case redshiftIdcApplicationQuotaExceededFault = "RedshiftIdcApplicationQuotaExceeded"
        case reservedNodeAlreadyExistsFault = "ReservedNodeAlreadyExists"
        case reservedNodeAlreadyMigratedFault = "ReservedNodeAlreadyMigrated"
        case reservedNodeExchangeNotFoundFault = "ReservedNodeExchangeNotFond"
        case reservedNodeNotFoundFault = "ReservedNodeNotFound"
        case reservedNodeOfferingNotFoundFault = "ReservedNodeOfferingNotFound"
        case reservedNodeQuotaExceededFault = "ReservedNodeQuotaExceeded"
        case resizeNotFoundFault = "ResizeNotFound"
        case resourceNotFoundFault = "ResourceNotFoundFault"
        case scheduleDefinitionTypeUnsupportedFault = "ScheduleDefinitionTypeUnsupported"
        case scheduledActionAlreadyExistsFault = "ScheduledActionAlreadyExists"
        case scheduledActionNotFoundFault = "ScheduledActionNotFound"
        case scheduledActionQuotaExceededFault = "ScheduledActionQuotaExceeded"
        case scheduledActionTypeUnsupportedFault = "ScheduledActionTypeUnsupported"
        case snapshotCopyAlreadyDisabledFault = "SnapshotCopyAlreadyDisabledFault"
        case snapshotCopyAlreadyEnabledFault = "SnapshotCopyAlreadyEnabledFault"
        case snapshotCopyDisabledFault = "SnapshotCopyDisabledFault"
        case snapshotCopyGrantAlreadyExistsFault = "SnapshotCopyGrantAlreadyExistsFault"
        case snapshotCopyGrantNotFoundFault = "SnapshotCopyGrantNotFoundFault"
        case snapshotCopyGrantQuotaExceededFault = "SnapshotCopyGrantQuotaExceededFault"
        case snapshotScheduleAlreadyExistsFault = "SnapshotScheduleAlreadyExists"
        case snapshotScheduleNotFoundFault = "SnapshotScheduleNotFound"
        case snapshotScheduleQuotaExceededFault = "SnapshotScheduleQuotaExceeded"
        case snapshotScheduleUpdateInProgressFault = "SnapshotScheduleUpdateInProgress"
        case snsInvalidTopicFault = "SNSInvalidTopic"
        case snsNoAuthorizationFault = "SNSNoAuthorization"
        case snsTopicArnNotFoundFault = "SNSTopicArnNotFound"
        case sourceNotFoundFault = "SourceNotFound"
        case subnetAlreadyInUse = "SubnetAlreadyInUse"
        case subscriptionAlreadyExistFault = "SubscriptionAlreadyExist"
        case subscriptionCategoryNotFoundFault = "SubscriptionCategoryNotFound"
        case subscriptionEventIdNotFoundFault = "SubscriptionEventIdNotFound"
        case subscriptionNotFoundFault = "SubscriptionNotFound"
        case subscriptionSeverityNotFoundFault = "SubscriptionSeverityNotFound"
        case tableLimitExceededFault = "TableLimitExceeded"
        case tableRestoreNotFoundFault = "TableRestoreNotFoundFault"
        case tagLimitExceededFault = "TagLimitExceededFault"
        case unauthorizedOperation = "UnauthorizedOperation"
        case unauthorizedPartnerIntegrationFault = "UnauthorizedPartnerIntegration"
        case unknownSnapshotCopyRegionFault = "UnknownSnapshotCopyRegionFault"
        case unsupportedOperationFault = "UnsupportedOperation"
        case unsupportedOptionFault = "UnsupportedOptionFault"
        case usageLimitAlreadyExistsFault = "UsageLimitAlreadyExists"
        case usageLimitNotFoundFault = "UsageLimitNotFound"
    }

    private let error: Code
    public let context: AWSErrorContext?

    /// initialize Redshift
    public init?(errorCode: String, context: AWSErrorContext) {
        guard let error = Code(rawValue: errorCode) else { return nil }
        self.error = error
        self.context = context
    }

    internal init(_ error: Code) {
        self.error = error
        self.context = nil
    }

    /// return error code string
    public var errorCode: String { self.error.rawValue }

    /// You are not authorized to access the cluster.
    public static var accessToClusterDeniedFault: Self { .init(.accessToClusterDeniedFault) }
    /// The owner of the specified snapshot has not authorized your account to access the snapshot.
    public static var accessToSnapshotDeniedFault: Self { .init(.accessToSnapshotDeniedFault) }
    /// The authentication profile already exists.
    public static var authenticationProfileAlreadyExistsFault: Self { .init(.authenticationProfileAlreadyExistsFault) }
    /// The authentication profile can't be found.
    public static var authenticationProfileNotFoundFault: Self { .init(.authenticationProfileNotFoundFault) }
    /// The size or number of authentication profiles has exceeded the quota. The maximum length of the JSON string and maximum number of authentication profiles is determined by a quota for your account.
    public static var authenticationProfileQuotaExceededFault: Self { .init(.authenticationProfileQuotaExceededFault) }
    /// The specified CIDR block or EC2 security group is already authorized for the specified cluster security group.
    public static var authorizationAlreadyExistsFault: Self { .init(.authorizationAlreadyExistsFault) }
    /// The specified CIDR IP range or EC2 security group is not authorized for the specified cluster security group.
    public static var authorizationNotFoundFault: Self { .init(.authorizationNotFoundFault) }
    /// The authorization quota for the cluster security group has been reached.
    public static var authorizationQuotaExceededFault: Self { .init(.authorizationQuotaExceededFault) }
    /// The maximum number for a batch delete of snapshots has been reached. The limit is 100.
    public static var batchDeleteRequestSizeExceededFault: Self { .init(.batchDeleteRequestSizeExceededFault) }
    /// The maximum number for snapshot identifiers has been reached. The limit is 100.
    public static var batchModifyClusterSnapshotsLimitExceededFault: Self { .init(.batchModifyClusterSnapshotsLimitExceededFault) }
    /// Could not find the specified S3 bucket.
    public static var bucketNotFoundFault: Self { .init(.bucketNotFoundFault) }
    /// The account already has a cluster with the given identifier.
    public static var clusterAlreadyExistsFault: Self { .init(.clusterAlreadyExistsFault) }
    /// The ClusterIdentifier parameter does not refer to an existing cluster.
    public static var clusterNotFoundFault: Self { .init(.clusterNotFoundFault) }
    /// Cluster is already on the latest database revision.
    public static var clusterOnLatestRevisionFault: Self { .init(.clusterOnLatestRevisionFault) }
    /// A cluster parameter group with the same name already exists.
    public static var clusterParameterGroupAlreadyExistsFault: Self { .init(.clusterParameterGroupAlreadyExistsFault) }
    /// The parameter group name does not refer to an existing parameter group.
    public static var clusterParameterGroupNotFoundFault: Self { .init(.clusterParameterGroupNotFoundFault) }
    /// The request would result in the user exceeding the allowed number of cluster parameter groups.
    /// For information about increasing your quota, go to Limits in Amazon Redshift
    /// in the Amazon Redshift Cluster Management Guide.
    public static var clusterParameterGroupQuotaExceededFault: Self { .init(.clusterParameterGroupQuotaExceededFault) }
    /// The request would exceed the allowed number of cluster instances for this account.
    /// For information about increasing your quota, go to Limits in Amazon Redshift
    /// in the Amazon Redshift Cluster Management Guide.
    public static var clusterQuotaExceededFault: Self { .init(.clusterQuotaExceededFault) }
    /// A cluster security group with the same name already exists.
    public static var clusterSecurityGroupAlreadyExistsFault: Self { .init(.clusterSecurityGroupAlreadyExistsFault) }
    /// The cluster security group name does not refer to an existing cluster security group.
    public static var clusterSecurityGroupNotFoundFault: Self { .init(.clusterSecurityGroupNotFoundFault) }
    /// The request would result in the user exceeding the allowed number of cluster security groups.
    /// For information about increasing your quota, go to Limits in Amazon Redshift
    /// in the Amazon Redshift Cluster Management Guide.
    public static var clusterSecurityGroupQuotaExceededFault: Self { .init(.clusterSecurityGroupQuotaExceededFault) }
    /// The value specified as a snapshot identifier is already used by an existing snapshot.
    public static var clusterSnapshotAlreadyExistsFault: Self { .init(.clusterSnapshotAlreadyExistsFault) }
    /// The snapshot identifier does not refer to an existing cluster snapshot.
    public static var clusterSnapshotNotFoundFault: Self { .init(.clusterSnapshotNotFoundFault) }
    /// The request would result in the user exceeding the allowed number of cluster snapshots.
    public static var clusterSnapshotQuotaExceededFault: Self { .init(.clusterSnapshotQuotaExceededFault) }
    /// A ClusterSubnetGroupName is already used by an existing cluster subnet group.
    public static var clusterSubnetGroupAlreadyExistsFault: Self { .init(.clusterSubnetGroupAlreadyExistsFault) }
    /// The cluster subnet group name does not refer to an existing cluster subnet group.
    public static var clusterSubnetGroupNotFoundFault: Self { .init(.clusterSubnetGroupNotFoundFault) }
    /// The request would result in user exceeding the allowed number of cluster subnet groups.
    /// For information about increasing your quota, go to Limits in Amazon Redshift
    /// in the Amazon Redshift Cluster Management Guide.
    public static var clusterSubnetGroupQuotaExceededFault: Self { .init(.clusterSubnetGroupQuotaExceededFault) }
    /// The request would result in user exceeding the allowed number of subnets in a cluster subnet groups.
    /// For information about increasing your quota, go to Limits in Amazon Redshift
    /// in the Amazon Redshift Cluster Management Guide.
    public static var clusterSubnetQuotaExceededFault: Self { .init(.clusterSubnetQuotaExceededFault) }
    /// There is a conflict while updating the resource policy.
    public static var conflictPolicyUpdateFault: Self { .init(.conflictPolicyUpdateFault) }
    /// Cross-region snapshot copy was temporarily disabled. Try your request again.
    public static var copyToRegionDisabledFault: Self { .init(.copyToRegionDisabledFault) }
    /// An error occurred when an attempt was made to change the custom domain association.
    public static var customCnameAssociationFault: Self { .init(.customCnameAssociationFault) }
    /// An error occurred. The custom domain name couldn't be found.
    public static var customDomainAssociationNotFoundFault: Self { .init(.customDomainAssociationNotFoundFault) }
    /// A dependent service denied access for the integration.
    public static var dependentServiceAccessDeniedFault: Self { .init(.dependentServiceAccessDeniedFault) }
    /// The request cannot be completed because a dependent service is throttling requests made by Amazon Redshift on your behalf. Wait and retry the request.
    public static var dependentServiceRequestThrottlingFault: Self { .init(.dependentServiceRequestThrottlingFault) }
    /// Your request cannot be completed because a dependent internal service is temporarily unavailable. Wait 30 to 60 seconds and try again.
    public static var dependentServiceUnavailableFault: Self { .init(.dependentServiceUnavailableFault) }
    /// The account already has a Redshift-managed VPC endpoint with the given identifier.
    public static var endpointAlreadyExistsFault: Self { .init(.endpointAlreadyExistsFault) }
    /// The authorization already exists for this endpoint.
    public static var endpointAuthorizationAlreadyExistsFault: Self { .init(.endpointAuthorizationAlreadyExistsFault) }
    /// The authorization for this endpoint can't be found.
    public static var endpointAuthorizationNotFoundFault: Self { .init(.endpointAuthorizationNotFoundFault) }
    /// The number of endpoint authorizations per cluster has exceeded its limit.
    public static var endpointAuthorizationsPerClusterLimitExceededFault: Self { .init(.endpointAuthorizationsPerClusterLimitExceededFault) }
    /// The endpoint name doesn't refer to an existing endpoint.
    public static var endpointNotFoundFault: Self { .init(.endpointNotFoundFault) }
    /// The number of Redshift-managed VPC endpoints per authorization has exceeded its limit.
    public static var endpointsPerAuthorizationLimitExceededFault: Self { .init(.endpointsPerAuthorizationLimitExceededFault) }
    /// The number of Redshift-managed VPC endpoints per cluster has exceeded its limit.
    public static var endpointsPerClusterLimitExceededFault: Self { .init(.endpointsPerClusterLimitExceededFault) }
    /// The request would exceed the allowed number of event subscriptions for this account.
    /// For information about increasing your quota, go to Limits in Amazon Redshift
    /// in the Amazon Redshift Cluster Management Guide.
    public static var eventSubscriptionQuotaExceededFault: Self { .init(.eventSubscriptionQuotaExceededFault) }
    /// There is already an existing Amazon Redshift HSM client certificate with the specified identifier.
    public static var hsmClientCertificateAlreadyExistsFault: Self { .init(.hsmClientCertificateAlreadyExistsFault) }
    /// There is no Amazon Redshift HSM client certificate with the specified identifier.
    public static var hsmClientCertificateNotFoundFault: Self { .init(.hsmClientCertificateNotFoundFault) }
    /// The quota for HSM client certificates has been reached.
    /// For information about increasing your quota, go to Limits in Amazon Redshift
    /// in the Amazon Redshift Cluster Management Guide.
    public static var hsmClientCertificateQuotaExceededFault: Self { .init(.hsmClientCertificateQuotaExceededFault) }
    /// There is already an existing Amazon Redshift HSM configuration with the specified identifier.
    public static var hsmConfigurationAlreadyExistsFault: Self { .init(.hsmConfigurationAlreadyExistsFault) }
    /// There is no Amazon Redshift HSM configuration with the specified identifier.
    public static var hsmConfigurationNotFoundFault: Self { .init(.hsmConfigurationNotFoundFault) }
    /// The quota for HSM configurations has been reached.
    /// For information about increasing your quota, go to Limits in Amazon Redshift
    /// in the Amazon Redshift Cluster Management Guide.
    public static var hsmConfigurationQuotaExceededFault: Self { .init(.hsmConfigurationQuotaExceededFault) }
    /// You have exceeded the allowed number of table restore requests. Wait for your current table restore requests to complete before making a new request.
    public static var inProgressTableRestoreQuotaExceededFault: Self { .init(.inProgressTableRestoreQuotaExceededFault) }
    /// The specified options are incompatible.
    public static var incompatibleOrderableOptions: Self { .init(.incompatibleOrderableOptions) }
    /// The number of nodes specified exceeds the allotted capacity of the cluster.
    public static var insufficientClusterCapacityFault: Self { .init(.insufficientClusterCapacityFault) }
    /// The cluster does not have read bucket or put object permissions on the S3 bucket specified when enabling logging.
    public static var insufficientS3BucketPolicyFault: Self { .init(.insufficientS3BucketPolicyFault) }
    /// The integration you are trying to create already exists.
    public static var integrationAlreadyExistsFault: Self { .init(.integrationAlreadyExistsFault) }
    /// A conflicting conditional operation is currently in progress against this resource. This typically occurs when there are multiple requests being made to the same resource at the same time, and these requests conflict with each other.
    public static var integrationConflictOperationFault: Self { .init(.integrationConflictOperationFault) }
    /// The integration is in an invalid state and can't perform the requested operation.
    public static var integrationConflictStateFault: Self { .init(.integrationConflictStateFault) }
    /// The integration can't be found.
    public static var integrationNotFoundFault: Self { .init(.integrationNotFoundFault) }
    /// You can't create any more zero-ETL or S3 event integrations because the quota has been reached.
    public static var integrationQuotaExceededFault: Self { .init(.integrationQuotaExceededFault) }
    /// The specified integration source can't be found.
    public static var integrationSourceNotFoundFault: Self { .init(.integrationSourceNotFoundFault) }
    /// The specified integration target can't be found.
    public static var integrationTargetNotFoundFault: Self { .init(.integrationTargetNotFoundFault) }
    /// The authentication profile request is not valid. The profile name can't be null or empty.  The authentication profile API operation must be available in the Amazon Web Services Region.
    public static var invalidAuthenticationProfileRequestFault: Self { .init(.invalidAuthenticationProfileRequestFault) }
    /// The status of the authorization is not valid.
    public static var invalidAuthorizationStateFault: Self { .init(.invalidAuthorizationStateFault) }
    /// The cluster parameter group action can not be completed because another task is in progress that involves the parameter group. Wait a few moments and try the operation again.
    public static var invalidClusterParameterGroupStateFault: Self { .init(.invalidClusterParameterGroupStateFault) }
    /// The state of the cluster security group is not available.
    public static var invalidClusterSecurityGroupStateFault: Self { .init(.invalidClusterSecurityGroupStateFault) }
    /// The cluster snapshot schedule state is not valid.
    public static var invalidClusterSnapshotScheduleStateFault: Self { .init(.invalidClusterSnapshotScheduleStateFault) }
    /// The specified cluster snapshot is not in the available state, or other accounts are authorized to access the snapshot.
    public static var invalidClusterSnapshotStateFault: Self { .init(.invalidClusterSnapshotStateFault) }
    /// The specified cluster is not in the available state.
    public static var invalidClusterStateFault: Self { .init(.invalidClusterStateFault) }
    /// The cluster subnet group cannot be deleted because it is in use.
    public static var invalidClusterSubnetGroupStateFault: Self { .init(.invalidClusterSubnetGroupStateFault) }
    /// The state of the subnet is invalid.
    public static var invalidClusterSubnetStateFault: Self { .init(.invalidClusterSubnetStateFault) }
    /// The provided cluster track name is not valid.
    public static var invalidClusterTrackFault: Self { .init(.invalidClusterTrackFault) }
    /// There is an error with the datashare.
    public static var invalidDataShareFault: Self { .init(.invalidDataShareFault) }
    /// The Elastic IP (EIP) is invalid or cannot be found.
    public static var invalidElasticIpFault: Self { .init(.invalidElasticIpFault) }
    /// The status of the endpoint is not valid.
    public static var invalidEndpointStateFault: Self { .init(.invalidEndpointStateFault) }
    /// The specified HSM client certificate is not in the available state, or it is still in use by one or more Amazon Redshift clusters.
    public static var invalidHsmClientCertificateStateFault: Self { .init(.invalidHsmClientCertificateStateFault) }
    /// The specified HSM configuration is not in the available state, or it is still in use by one or more Amazon Redshift clusters.
    public static var invalidHsmConfigurationStateFault: Self { .init(.invalidHsmConfigurationStateFault) }
    /// The namespace isn't valid because the namespace doesn't exist. Provide a valid namespace.
    public static var invalidNamespaceFault: Self { .init(.invalidNamespaceFault) }
    /// The resource policy isn't valid.
    public static var invalidPolicyFault: Self { .init(.invalidPolicyFault) }
    /// Indicates that the Reserved Node being exchanged is not in an active state.
    public static var invalidReservedNodeStateFault: Self { .init(.invalidReservedNodeStateFault) }
    /// The restore is invalid.
    public static var invalidRestoreFault: Self { .init(.invalidRestoreFault) }
    /// The retention period specified is either in the past or is not a valid value. The value must be either -1 or an integer between 1 and 3,653.
    public static var invalidRetentionPeriodFault: Self { .init(.invalidRetentionPeriodFault) }
    /// The S3 bucket name is invalid. For more information about naming rules, go to Bucket Restrictions and Limitations in the Amazon Simple Storage Service (S3) Developer Guide.
    public static var invalidS3BucketNameFault: Self { .init(.invalidS3BucketNameFault) }
    /// The string specified for the logging S3 key prefix does not comply with the documented constraints.
    public static var invalidS3KeyPrefixFault: Self { .init(.invalidS3KeyPrefixFault) }
    /// The schedule you submitted isn't valid.
    public static var invalidScheduleFault: Self { .init(.invalidScheduleFault) }
    /// The scheduled action is not valid.
    public static var invalidScheduledActionFault: Self { .init(.invalidScheduledActionFault) }
    /// The snapshot copy grant can't be deleted because it is used by one or more clusters.
    public static var invalidSnapshotCopyGrantStateFault: Self { .init(.invalidSnapshotCopyGrantStateFault) }
    /// The requested subnet is not valid, or not all of the subnets are in the same VPC.
    public static var invalidSubnet: Self { .init(.invalidSubnet) }
    /// The subscription request is invalid because it is a duplicate request. This subscription request is already in progress.
    public static var invalidSubscriptionStateFault: Self { .init(.invalidSubscriptionStateFault) }
    /// The value specified for the sourceDatabaseName, sourceSchemaName, or sourceTableName parameter, or a combination of these, doesn't exist in the snapshot.
    public static var invalidTableRestoreArgumentFault: Self { .init(.invalidTableRestoreArgumentFault) }
    /// The tag is invalid.
    public static var invalidTagFault: Self { .init(.invalidTagFault) }
    /// The usage limit is not valid.
    public static var invalidUsageLimitFault: Self { .init(.invalidUsageLimitFault) }
    /// The cluster subnet group does not cover all Availability Zones.
    public static var invalidVPCNetworkStateFault: Self { .init(.invalidVPCNetworkStateFault) }
    /// There are no subnets in your VPC with associated IPv6 CIDR blocks. To use dual-stack mode, associate an IPv6 CIDR block with each subnet in your VPC.
    public static var ipv6CidrBlockNotFoundFault: Self { .init(.ipv6CidrBlockNotFoundFault) }
    /// The encryption key has exceeded its grant limit in Amazon Web Services KMS.
    public static var limitExceededFault: Self { .init(.limitExceededFault) }
    /// The operation would exceed the number of nodes allowed for a cluster.
    public static var numberOfNodesPerClusterLimitExceededFault: Self { .init(.numberOfNodesPerClusterLimitExceededFault) }
    /// The operation would exceed the number of nodes allotted to the account.
    /// For information about increasing your quota, go to Limits in Amazon Redshift
    /// in the Amazon Redshift Cluster Management Guide.
    public static var numberOfNodesQuotaExceededFault: Self { .init(.numberOfNodesQuotaExceededFault) }
    /// The name of the partner was not found.
    public static var partnerNotFoundFault: Self { .init(.partnerNotFoundFault) }
    /// The application you attempted to add already exists.
    public static var redshiftIdcApplicationAlreadyExistsFault: Self { .init(.redshiftIdcApplicationAlreadyExistsFault) }
    /// The application you attempted to find doesn't exist.
    public static var redshiftIdcApplicationNotExistsFault: Self { .init(.redshiftIdcApplicationNotExistsFault) }
    /// The maximum number of Redshift IAM Identity Center applications was exceeded.
    public static var redshiftIdcApplicationQuotaExceededFault: Self { .init(.redshiftIdcApplicationQuotaExceededFault) }
    /// User already has a reservation with the given identifier.
    public static var reservedNodeAlreadyExistsFault: Self { .init(.reservedNodeAlreadyExistsFault) }
    /// Indicates that the reserved node has already been exchanged.
    public static var reservedNodeAlreadyMigratedFault: Self { .init(.reservedNodeAlreadyMigratedFault) }
    /// The reserved-node exchange status wasn't found.
    public static var reservedNodeExchangeNotFoundFault: Self { .init(.reservedNodeExchangeNotFoundFault) }
    /// The specified reserved compute node not found.
    public static var reservedNodeNotFoundFault: Self { .init(.reservedNodeNotFoundFault) }
    /// Specified offering does not exist.
    public static var reservedNodeOfferingNotFoundFault: Self { .init(.reservedNodeOfferingNotFoundFault) }
    /// Request would exceed the user's compute node quota.
    /// For information about increasing your quota, go to Limits in Amazon Redshift
    /// in the Amazon Redshift Cluster Management Guide.
    public static var reservedNodeQuotaExceededFault: Self { .init(.reservedNodeQuotaExceededFault) }
    /// A resize operation for the specified cluster is not found.
    public static var resizeNotFoundFault: Self { .init(.resizeNotFoundFault) }
    /// The resource could not be found.
    public static var resourceNotFoundFault: Self { .init(.resourceNotFoundFault) }
    /// The definition you submitted is not supported.
    public static var scheduleDefinitionTypeUnsupportedFault: Self { .init(.scheduleDefinitionTypeUnsupportedFault) }
    /// The scheduled action already exists.
    public static var scheduledActionAlreadyExistsFault: Self { .init(.scheduledActionAlreadyExistsFault) }
    /// The scheduled action cannot be found.
    public static var scheduledActionNotFoundFault: Self { .init(.scheduledActionNotFoundFault) }
    /// The quota for scheduled actions exceeded.
    public static var scheduledActionQuotaExceededFault: Self { .init(.scheduledActionQuotaExceededFault) }
    /// The action type specified for a scheduled action is not supported.
    public static var scheduledActionTypeUnsupportedFault: Self { .init(.scheduledActionTypeUnsupportedFault) }
    /// The cluster already has cross-region snapshot copy disabled.
    public static var snapshotCopyAlreadyDisabledFault: Self { .init(.snapshotCopyAlreadyDisabledFault) }
    /// The cluster already has cross-region snapshot copy enabled.
    public static var snapshotCopyAlreadyEnabledFault: Self { .init(.snapshotCopyAlreadyEnabledFault) }
    /// Cross-region snapshot copy was temporarily disabled. Try your request again.
    public static var snapshotCopyDisabledFault: Self { .init(.snapshotCopyDisabledFault) }
    /// The snapshot copy grant can't be created because a grant with the same name already exists.
    public static var snapshotCopyGrantAlreadyExistsFault: Self { .init(.snapshotCopyGrantAlreadyExistsFault) }
    /// The specified snapshot copy grant can't be found. Make sure that the name is typed correctly and that the grant exists in the destination region.
    public static var snapshotCopyGrantNotFoundFault: Self { .init(.snapshotCopyGrantNotFoundFault) }
    /// The Amazon Web Services account has exceeded the maximum number of snapshot copy grants in this region.
    public static var snapshotCopyGrantQuotaExceededFault: Self { .init(.snapshotCopyGrantQuotaExceededFault) }
    /// The specified snapshot schedule already exists.
    public static var snapshotScheduleAlreadyExistsFault: Self { .init(.snapshotScheduleAlreadyExistsFault) }
    /// We could not find the specified snapshot schedule.
    public static var snapshotScheduleNotFoundFault: Self { .init(.snapshotScheduleNotFoundFault) }
    /// You have exceeded the quota of snapshot schedules.
    public static var snapshotScheduleQuotaExceededFault: Self { .init(.snapshotScheduleQuotaExceededFault) }
    /// The specified snapshot schedule is already being updated.
    public static var snapshotScheduleUpdateInProgressFault: Self { .init(.snapshotScheduleUpdateInProgressFault) }
    /// Amazon SNS has responded that there is a problem with the specified Amazon SNS topic.
    public static var snsInvalidTopicFault: Self { .init(.snsInvalidTopicFault) }
    /// You do not have permission to publish to the specified Amazon SNS topic.
    public static var snsNoAuthorizationFault: Self { .init(.snsNoAuthorizationFault) }
    /// An Amazon SNS topic with the specified Amazon Resource Name (ARN) does not exist.
    public static var snsTopicArnNotFoundFault: Self { .init(.snsTopicArnNotFoundFault) }
    /// The specified Amazon Redshift event source could not be found.
    public static var sourceNotFoundFault: Self { .init(.sourceNotFoundFault) }
    /// A specified subnet is already in use by another cluster.
    public static var subnetAlreadyInUse: Self { .init(.subnetAlreadyInUse) }
    /// There is already an existing event notification subscription with the specified name.
    public static var subscriptionAlreadyExistFault: Self { .init(.subscriptionAlreadyExistFault) }
    /// The value specified for the event category was not one of the allowed values, or it specified a category that does not apply to the specified source type. The allowed values are Configuration, Management, Monitoring, and Security.
    public static var subscriptionCategoryNotFoundFault: Self { .init(.subscriptionCategoryNotFoundFault) }
    /// An Amazon Redshift event with the specified event ID does not exist.
    public static var subscriptionEventIdNotFoundFault: Self { .init(.subscriptionEventIdNotFoundFault) }
    /// An Amazon Redshift event notification subscription with the specified name does not exist.
    public static var subscriptionNotFoundFault: Self { .init(.subscriptionNotFoundFault) }
    /// The value specified for the event severity was not one of the allowed values, or it specified a severity that does not apply to the specified source type. The allowed values are ERROR and INFO.
    public static var subscriptionSeverityNotFoundFault: Self { .init(.subscriptionSeverityNotFoundFault) }
    /// The number of tables in the cluster exceeds the limit for the requested new cluster node type.
    public static var tableLimitExceededFault: Self { .init(.tableLimitExceededFault) }
    /// The specified TableRestoreRequestId value was not found.
    public static var tableRestoreNotFoundFault: Self { .init(.tableRestoreNotFoundFault) }
    /// You have exceeded the number of tags allowed.
    public static var tagLimitExceededFault: Self { .init(.tagLimitExceededFault) }
    /// Your account is not authorized to perform the requested operation.
    public static var unauthorizedOperation: Self { .init(.unauthorizedOperation) }
    /// The partner integration is not authorized.
    public static var unauthorizedPartnerIntegrationFault: Self { .init(.unauthorizedPartnerIntegrationFault) }
    /// The specified region is incorrect or does not exist.
    public static var unknownSnapshotCopyRegionFault: Self { .init(.unknownSnapshotCopyRegionFault) }
    /// The requested operation isn't supported.
    public static var unsupportedOperationFault: Self { .init(.unsupportedOperationFault) }
    /// A request option was specified that is not supported.
    public static var unsupportedOptionFault: Self { .init(.unsupportedOptionFault) }
    /// The usage limit already exists.
    public static var usageLimitAlreadyExistsFault: Self { .init(.usageLimitAlreadyExistsFault) }
    /// The usage limit identifier can't be found.
    public static var usageLimitNotFoundFault: Self { .init(.usageLimitNotFoundFault) }
}

extension RedshiftErrorType: Equatable {
    public static func == (lhs: RedshiftErrorType, rhs: RedshiftErrorType) -> Bool {
        lhs.error == rhs.error
    }
}

extension RedshiftErrorType: CustomStringConvertible {
    public var description: String {
        return "\(self.error.rawValue): \(self.message ?? "")"
    }
}
